类--模具
实例化出来的对象--模具做出来的产品
模版--模具的图纸
模版--实例化--》类(模具)---实例化对象(产品)
模板和特例化返回值一致，函数名一致，参数格式一致
模板类型是在编译期进行确定，确定好模板类型之后实例化成具体的
函数/类，以供使用
模板是否都会实例化呢？
特例化会直接编译，不用实例化
普通模板只有调用才会编译
模板只有调用了才会实例化，会根据调用的类型实例化出对应的函
数/类
模板在编译期间进行实例化
普通函数>特例化版本>模版
普通函数：整形，浮点型
template<typename T> bool compare(T a, T b)//比较 含参 { cout << "bool compare(T a, T b) " << typeid(T).name() << endl;//进行输出 // typeid(T).name() 输出类型名 return a > b;//若为真 返回值 为假返回0 }
函数重载 是在编译期确定需要调用的函数
函数模板 是在编译期确定需要实例化的函数类型
函数模板实例化出来的多个函数之间是重载关系--包括函数模板的特例化
静多态包含：编译期间的多态 ，函数重载 ，模板
函数重载：
bool compare(int a, int b) { cout << "bool compare(int a, int b)" << endl; return a > b; } bool compare(char a, char b) { return a > b; } bool compare(const char* a,const char* b)//传常量字符串 { cout << "bool compare(const char* a,const char* b)" << endl; return strcmp(a,b) > 0; }
特例化版本：
字符串：
template<> bool compare<const char*>(const char* a, const char* b) { cout << "bool compare<const char*>(const char* a, const char* b)" << endl; return strcmp(a, b) > 0; }
普通：
template<typename ZPL>//先指定类型代表 void Msort(ZPL* arr, int len) { if (NULL == arr) { return; } ZPL tmp = ZPL();// 相当于int tmp=0; for (int i = 0; i < len; i++) { for (int j = 0; j < len - i - 1; j++) { if (arr[j] < arr[j + 1]) { tmp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = tmp; } } } }
特例化：
template<> void Msort<const char*>(const char** arr, int len)//const char* 又因为是数组 *arr { if (NULL == arr) { return; } const char* tmp = NULL;//进行指定 for (int i = 0; i < len; i++) { for (int j = 0; j < len - i - 1; j++) { if (arr[j] && arr[j + 1])//判断他两同时不为空 { if (strcmp(arr[j], arr[j + 1]) < 0)//const char* 时使用strcmp { tmp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = tmp; } } } } }
函数模版：
template<typename T> class Arr { private: T* _arr; int _len; int _size; void revert() { _len = _len << 1; T* tmp = new T[_len]; memset(tmp, T(), _len); for (int i = 0; i < _size; i++) { tmp[i] = _arr[i]; } delete[]_arr; _arr = tmp; } public: Arr(int len = 10); Arr(T* arr, int size); Arr(const Arr& src); ~Arr(); Arr& operator=(const Arr& src); void push_back(T val); void sort(); bool is_full() { return _size == _len; } int size()//排序时使用，可不使用友元 { return _size; } T* get_arr() { return _arr; } //template<typename T>//字母T 可换其他字母 //friend ostream& operator<<(ostream& out, Arr<T>& src);//T可换 }; template<typename T>//重新定义T Arr<T>::Arr(int len)//声明作用域Arr<T> 上面是默认值，下面是参数 { _len = len; _arr = new T[_len]; memset(_arr, T(), _len);//进行初始化 T类型 默认值为len _size = 0; } template<typename T> Arr<T>::Arr(T* arr, int size) { _len = size; _size = size; _arr = new T[_len]; memset(_arr, T(), _len); for (int i = 0; i < _len; i++) { _arr[i] = arr[i]; } } template<typename T> Arr<T>::Arr(const Arr& src)//拷贝构造 { _len = src._len; _size = src._size; _arr = new T[_len]; memset(_arr, T(), _len); for (int i = 0; i < _size; i++)//防止浅拷贝 { _arr[i] = src._arr[i]; } } template<typename T> Arr<T>::~Arr() { delete[]_arr; _arr = NULL; _size = _len = 0; } template<typename T> Arr<T>& Arr<T>::operator=(const Arr& src)//等号运算符 { if (&src == this) { return *this; } delete _arr; _len = src._len; _size = src._size; _arr = new T[_len]; memset(_arr, T(), _len); for (int i = 0; i < _size; i++) { _arr[i] = src._arr[i]; } return *this; } template<typename T> void Arr<T>::push_back(T val)//从后面放 { if (is_full()) { revert();//申请空间 } _arr[_size++] = val; } template<typename T> void Arr<T>::sort()//排序 { T tmp = T(); for (int i = 0; i < _size; i++) { for (int j = 0; j < _size - i - 1; j++) { if (_arr[j] < _arr[j + 1]) { tmp = _arr[j]; _arr[j] = _arr[j + 1]; _arr[j + 1] = tmp; } } } } template<typename T>//重新定义T （Arr<T>中的T） ostream& operator<<(ostream& out, Arr<T>& src)//类外输出运算符重载 { for (int i = 0; i < src.size(); i++) { cout << src.get_arr()[i] << " "; } cout << endl; return out; }
原文：https://www.cnblogs.com/xpei-1124/p/14904630.html