1、函数模板
函数模板代表了一个函数家族,该函数模板与类型无关,在使用时被参数化,根据实参类型产生函数的特定 类型版本。
格式:template<typename T1, typename T2,…,typename Tn>
template <typename T>
void Swap(T& left,T& right){
T temp = left;
left = right;
right = temp;
}
注意:typename是用来定义模板参数关键字,也可以使用class(切记:不能使用struct代替class)
2、函数模板的实例化
1、隐式实例化:让编译器根据实参推演模板参数的实际类型
template <typename T>
T Add(T& i,T&j){
return i+j;
}
int main(){
int i 1= 10,j1=20;
double i2=10.0,j2=20.0;
Add(i1,j1);
Add(i2,j2);
Add(i1,(int)i2);
}
2、显示实例化:显示在函数名后的<>中指定模板参数的实际类实例化
int main(){
int i=10;
double j=20.0;
Add<int>(i,j);
return 0;
}
3、类模板
template<class T1, class T2, ..., class Tn>
class 类模板名 {
// 类内成员定义
};
动态顺序表:
typedef int DataType;
typedef char DataType;
template<class T>
class Vector{
public:
Vector(size_t capacity = 10)
:_data(new T[capacity])
, size(0)
, capacity(capacity)
{}
Vector();
void pushBack(T x){
_data[_size++] = x;
}
const T& operator[](size_t i)const{
cout << "const T& operator[](size_t i)const" << endl;
assert(i < _size);
return _data[i];
}
T& operator[](size_t i)
{
cout << "T& operator[](size_t i)" << endl;
assert(i < _size);
return _data[i];
}
size_t Size()const{
return _size;
}
~Vector(){
if (_data){
delete[] _data;
_data = nullptr;
_size = 0;
_capacity = 0;
}
}
private:
T* _data;
size_t size;
size_t _capacity;
};
template <class T>
Vector<T>::~Vector()
{
if(_pData)
{
delete[] _pData;
}
}
注意:Vector不是具体的类,是编译器根据被实例化的类型生成具体类的模具
4、类模板的实例化
类模板实例化需要在类模板名字后跟<>,然后将实例化的类型放在<> 中即可,类模板名字不是真正的类,而实例化的结果才是真正的类。
template <class T>
Vector<int> s1;
s1.PushBack(1);
s1.PushBack(2);
s1.PushBack(3);
Vector<double> s2;
s2.PushBack(1.0);
s2.PushBack(2.0);
s2.PushBack(3.0);