C++初阶模板

函数模板

template<typename T1, typename T2,…,typename Tn>
返回值类型函数名(参数列表){}
注意：typename是用来定义模板参数关键字，也可以使用class(切记：不能使用struct代替class)

// 模板
// Type
//template<class T>
//template<typename T>
//template<typename T1, typename T2>
//
// 编译器用模板实例化生成对应的Swap函数
//
// 函数模板
template<class T>
void Swap(T& left, T& right)
{T temp = left;left = right;right = temp;
}int main()
{int i = 0, j = 1;Swap(i, j);double x = 1.1, y = 2.2;Swap(x, y);return 0;
}

执行的指令不一样，调用函数要建立栈帧大小不同建立的栈帧不一样，int开4个字节double开了8字节，所以调用的不是同一个函数

在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码，对于字符类型也是如此

编译器根据模板会实例化生成对应函数
不是所有都生成，用到什么就生成什么

函数模板的实例化

隐式实例化：让编译器根据实参推演模板参数的实际类型

template<class T>
T Add(const T& left, const T& right)
{return left + right;
}int main()
{cout << Add(1, 2) << endl;cout << Add(1.1, 2.2) << endl;return 0;
}

显式实例化：在函数名后的<>中指定模板参数的实际类型

template<class T>
T Add(const T& left, const T& right)
{return left + right;
}int main()
{cout << Add(1, 2) << endl;//cout << Add(1.1, 2) << endl;//如果类型不匹配，编译器会尝试进行隐式类型转换，如果无法转换成功编译器将会报错。注意：在模板中，编译器一般不会进行类型转换操作
此时有两种处理方式：1. 用户自己来强制转化 2. 使用显式实例化cout << Add((int)1.1, 2) << endl;cout << Add(1.1, (double)2) << endl;// 显示实例化cout << Add<int>(1.1, 2) << endl;cout << Add<double>(1.1, 2) << endl;return 0;
}

如果有自己写的函数，优先调用自己写的，如果要指定模板的就要显示实例化

int Add(int left, int right)
{return left + right;
}// 通用加法函数
template<class T>
T Add(T left, T right)
{return left + right;
}cout << Add(x, y) << endl;cout << Add<int>(x, y) << endl;//指定调用模板函数

无法推演类型时必须要显示实例化：

template<class T>
T* func(int n)
{return new T[n];
}
int* ptr = func<int>(10);

类模板

格式

template<class T1, class T2, ..., class Tn>
class 类模板名
{// 类内成员定义
};

类模板的实例化

typedef int DataType;
class Stack
{
public:Stack(size_t capacity = 4){cout << "Stack()" << endl;_array = new DataType[capacity];//_array = new char[0x7fffffff];_capacity = capacity;_size = 0;}void Push(DataType data){// CheckCapacity();_array[_size] = data;_size++;}~Stack(){cout << "~Stack()" << endl;delete[] _array;_array = nullptr;_size = _capacity = 0;}
private:// 内置类型DataType* _array;int _capacity;int _size;
};
int main()
{Stack st1; // intStack st2; // doublereturn 0;
}

一个栈存int，一个栈存double时typedef就不能很好解决，这时候可以用模板解决

template<class T>
class Stack
{
public:Stack(size_t capacity = 4){cout << "Stack()" << endl;_array = new T[capacity];_capacity = capacity;_size = 0;}void Push(const T& data)//T有可能是个自定义类型，加上引用{// CheckCapacity();_array[_size] = data;_size++;}~Stack(){cout << "~Stack()" << endl;delete[] _array;_array = nullptr;_size = _capacity = 0;}
private:T* _array;int _capacity;int _size;
};int main()
{// Stack类名，Stack<int>才是类型Stack<int> st1; // intStack<double> st2; // doublereturn 0;
}

函数模板可以通过对实参类型的推演，确定T的类型
类模板就需要显式实例化了
类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类。

类模板声明和定义分离的情况

对于普通的类，类名就是类型，所以使用时不用加上struct
类模板的类名不是类型

template<class T>
class Vector
{
public:Vector(size_t capacity = 10): _pData(new T[capacity]), _size(0), _capacity(capacity){}// 析构函数演示：在类中声明，在类外定义。~Vector();void PushBack(const T& data);void PopBack();// ...size_t Size() { return _size; }T& operator[](size_t pos){//assert(pos < _size);return _pData[pos];}private:T* _pData;size_t _size;size_t _capacity;
};//只能在类里用T，所以声明和定义分离时还要单独声明一下T
template<class T>
Vector<T>::~Vector()
{delete[] _pData;_pData = nullptr;
}// 类名 ： Vector
// 类型 ： Vector<T>int main()
{Vector<int> v;return 0;
}