模板、函数模板、类模板
一、模板
泛型(Generic Programming)即是指具有在多种数据类型上皆可操作的含意。泛型编程的代表作品 STL 是一种高效、泛型、可交互操作的软件组件。
泛型编程最初诞生于 C++中,目的是为了实现 C++的 STL(标准模板库)。其语言支持机制就是模板(Templates)。模板的精神其实很简单:参数化类型。换句话说, 把一个原本特定于某个类型的算法或类当中的类型信息抽掉,抽出来做成模板参数 T。
所谓函数模板，实际上是建立一个通用函数，其函数类型和形参类型不具体指定，用一个虚拟的类型来代表。这个通用函数就称为函数模板。
二、函数模板
1.语法格式
template 是语义是模板的意思,尖括号中先写关键字 typename 或是class，后面跟一个类型 T，此类即是虚拟的类型。至于为什么用 T,用的人多了,也就是 T 了。
2.函数模板的实例
调用过程是这样的,先将函数模板实在化为函数,然后再发生函数调用。
#define _CRT_SECURE_NO_WARNINGS #include <iostream> using namespace std; template<class T> void MySwap(T& a, T& b) { T temp = a; a = b; b = temp; } int main(void) { int a = 10; int b = 20; //1.自动类型推导 cout << "a:" << a << ",b:" << b << endl;//a:10,b:20 MySwap(a, b);//编译器根据你传的值，进行类型自动推导 cout << "a:" << a << ",b:" << b << endl;//a:20,b:10 //2.显式的指定类型 MySwap<int>(a, b); cout << "a:" << a << ",b:" << b << endl;//a:10, b:20 double da = 10.01; double db = 20.02; cout << "da:" << da << ",db:" << db << endl;//da:10.01,db:20.02 MySwap(da, db);//编译器根据你传的值，进行类型自动推导 cout << "da:" << da << ",db:" << db << endl;//da:20.02,db:10.01 MySwap<double>(da, db); cout << "da:" << da << ",db:" << db << endl;//da:10.01,db:20.02 return 0; }
函数模板,只适用于函数的参数个数相同而类型不同,且函数体相同的情况。如果个数不同,则不能用函数模板。
3.函数模板与普通函数的区别
- 函数模板不允许自动类型转化
- 普通函数能够自动进行类型转化
4.函数模板和普通函数在一起调用规则
- 函数模板可以像普通函数那样被重载；
- C++编译器优先考虑普通函数；
- 如果函数模板可以产生一个更好的匹配，那么选择匹配；
- 可以通过空模板实参列表的语法限定编译器只能通过模板匹配。
5.编译器对模板机制剖析
编译器编译原理
总结：
（1）编译器并不是把函数模板处理成能够处理任意类的函数；
（2）编译器从函数模板通过具体类型产生不同的函数；
（3）编译器会对函数模板进行两次编译，在声明的地方对模板代码本身进行编译，在调用的地方对参数替换后的代码进行编译。
函数模板案例——char和int类型数组排序
#define _CRT_SECURE_NO_WARNINGS #include <iostream> using namespace std; //对char类型和int类型数组进行排序 //打印函数 template<class T> void PrintArray(T* arr, int len) { for (int i = 0;i < len;i++) { cout << arr[i] << " "; } cout << endl; } //排序 template<class T> void MySort(T* arr, int len) { for (int i = 0;i < len;i++) { for (int j = i + 1;j < len;j++) { //从大到小排序 if (arr[i] < arr[j]) { T temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } } } } int main(void) { int arr[] = { 2,6,1,8,9,2 }; int len = sizeof(arr) / sizeof(int); cout << "排序前："; PrintArray(arr,len);//排序前：2 6 1 8 9 2 MySort(arr, len); cout << "排序后："; PrintArray(arr, len);//排序后：9 8 6 2 2 1 char chArr[] = { 'a','c','q','d','t', }; len = sizeof(chArr) / sizeof(char); cout << "排序前："; PrintArray(chArr, len);//排序前：a c q d t MySort(chArr, len); cout << "排序后："; PrintArray(chArr, len);//排序后：t q d c a return 0; }
三、类模板
1.类模板定义
类模板与函数模板的定义和使用类似，有时，有两个或多个类，其功能是相同的，仅仅是数据类型不同，所以将类中的类型进行泛化。
类模板示例：
#define _CRT_SECURE_NO_WARNINGS #include <iostream> using namespace std; template<class T> class Person { public: Person(T id, T age) { this->m_id = id; this->m_age = age; } void Show() { cout << "id:" << this->m_id << ",age:" << this->m_age << endl; } public: T m_id; T m_age; }; void test() { //函数模板在调用的时候，可以自动类型推导 //类模板必须显式指定类型 Person<int> p(10, 20); p.Show(); } int main(void) { test();//id:10,age:20 return 0; }
2.类模板派生普通类、类模板派生类模板
#include <iostream> using namespace std; template<class T> class Person { public: Person(T age) { this->age = age; } private: T age; }; //模板类派生普通类 //为什么继承的类型需显式，而不是T？ //原因：类去定义对象，这个对象需要编译分配内存，所以要在 //public Person<int>这里显式的指定类型，可以知道给父类分配多少内存 class SubPerson1 :public Person<int> { public: SubPerson1(int age, int id) :Person<int>(age) { this->id = id; } private: int id; }; //模板类派生模板类 template<class T> class SubPerson2 :public Person<T> { public: SubPerson2(T age, T id) :Person<T>(age) { this->id = id; } private: int id; };
3、类模板实现
（1）类模板类内实现
（2）类模板类外实现（在一个.cpp中）
模板类不要轻易使用友元函数
（3）类模板类外实现（在.h和.cpp中）
由于二次编译，模板类在.h在第一次编译之后，并没有最终确定类的具体实现，只是编译器的词法校验和分析。在第二次确定类的具体实现后，是在.hpp文件生成的最后的具体类，所以main函数需要引入.hpp文件。
引入hpp文件一说也是曲线救国之计，所以实现模板方法建议在同一个文件.h中完成。
（4）类模板中的static
#define _CRT_SECURE_NO_WARNINGS #include <iostream> using namespace std; template<class T> class Person { public: static T a; }; //类外初始化 template<class T> T Person<T>::a = 0; int main(void) { Person<int> p1, p2, p3; Person<char> pp1, pp2, pp3; p1.a = 10; pp1.a = 'c'; cout << p1.a << " " << p2.a << " " << p3.a << endl;//10 10 10 cout << pp1.a << " " << pp2.a << " " << pp3.a << endl;//c c c
//通过以上结果，说明p1,p2,p3是属于Person<int>家族的,他们共享Person<int>::a; //pp1,pp2,pp3是属于Person<char>家族的,他们共享Person<char>::a; return 0; }
练习：
设计一个数组模板类（MyArray），完成对int、char类型元素的管理。
需要实现 构造函数 拷贝构造函数 [] 重载=操作符。
#define _CRT_SECURE_NO_WARNINGS #include <iostream> using namespace std; template<class T> class MyArray { public: MyArray(int capacity) { this->mCapacity = capacity; this->mSize = 0; //申请内存 this->pAddr = new T[this->mCapacity]; } MyArray(const MyArray<T>& arr) { this->mCapacity = arr.mCapacity; this->mSize = arr.mSize; //申请内存空间 this->pAddr = new T[this->mCapacity]; //数据拷贝 for (int i = 0; i < this->mSize;i++) { this->pAddr[i] = arr.pAddr[i]; } } T& operator[](int index) { return this->pAddr[index]; } MyArray<T> operator=(const MyArray<T>& arr) { if (this->pAddr != NULL) { delete[] this->pAddr; } this->mCapacity = arr.mCapacity; this->mSize = arr.mSize; //申请内存空间 this->pAddr = new T[this->mCapacity]; //数据拷贝 for (int i = 0; i < this->mSize;i++) { this->pAddr[i] = arr.pAddr[i]; } return *this; } void PushBack(T& data) { //判断容器中是否有位置 if (this->mSize >= this->mCapacity) { return; } //调用拷贝构造 =操作符 //1.对象元素必须能够被拷贝 //2.容器都是值寓意，而非引用寓意 向容器中放入元素，都是放入的元素的拷贝 //3.如果元素的成员有指针，注意深拷贝和浅拷贝问题 this->pAddr[this->mSize] = data; this->mSize ++ ; } //T&& 对右值取引用 void PushBack(T&& data) { //判断容器中是否有位置 if (this->mSize >= this->mCapacity) { return; } this->pAddr[this->mSize] = data; this->mSize++; } ~MyArray() { if (this->pAddr != NULL) { delete[] this->pAddr; } } public: //一共可以容下多少元素 int mCapacity; //当前数组有多少元素 int mSize; //保存数据的首地址 T* pAddr; }; class Person { }; void test2() { Person p1, p2; MyArray<Person> arr(10); arr.PushBack(p1); arr.PushBack(p2); } void test1() { MyArray<int> marray(20); int a = 10, b = 20, c = 30, d = 40; marray.PushBack(a); marray.PushBack(b); marray.PushBack(c); marray.PushBack(d); //不能对右值取引用 //左值 可以在多行使用 //临时变量 只能当前行使用 marray.PushBack(100); marray.PushBack(200); marray.PushBack(300); for (int i = 0;i < marray.mSize;i++) { cout << marray[i] << " "; } cout << endl; } int main(void) { test1(); return 0; }
