目录
一. 泛型编程
二. 函数模板
1. 概念
2. 函数模版格式
3. 函数模版的原理
4. 模版函数的实例化
(1). 隐式实例化
(2.) 显式实例化
5. 模版参数的匹配原则
三. 类模板
1. 类模板的定义格式
2. 类模板的实例化
四. STL的介绍
1. 什么是STL？
2. STL的版本
3. STL的六大组件
一. 泛型编程
我们之前实现一个交换函数，不同的类型就要用多个函数，我们学了函数重载比C语言时期方便了一点，不用想函数名了
如下代码
void Swap(int& xxxx, int& yyyy)
{
int temp = xxxx;
xxxx = yyyy;
yyyy = temp;
}
void Swap(double& xxxx, double& yyyy)
{
double temp = xxxx;
xxxx = yyyy;
yyyy = temp;
}
void Swap(char& xxxx, char& yyyy)
{
char temp = xxxx;
xxxx = yyyy;
yyyy = temp;
}
但是呢，仍然有很多不好的地方:
1. 重载的函数仅仅是类型不同，代码复用率比较低，只要有新类型出现时，就需要用户自己增加对应的函数
2. 代码的可维护性比较低，一个出错可能所有的重载均出错
那么能不能告诉编译器一个模子，让编译器根据不同类型利用模子来生成代码呢？
泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。
二. 函数模板
1. 概念
函数模版代表一个函数家族，该函数模版与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。
2. 函数模版格式
template<typename T1,typename T2,..........,typename Tn>
返回值类型 函数名 (参数列表) {}
如以下代码所示
template <typename T>
void Swap(T& xxxx, T& yyyy)
{
T temp = xxxx;
xxxx = yyyy;
yyyy = temp;
}typename 是用来定义模板参数关键字，也可以使用class(尤其注意：不要用struct替代class)
如下
template <class T>
void Swap(T& xxxx, T& yyyy)
{
T temp = xxxx;
xxxx = yyyy;
yyyy = temp;
}3. 函数模版的原理
函数模版是一个蓝图，它本身不是函数，是编译器根据使用方式产生特定具体类型函数的模具。所以其实模版就是将原本应该我们做的重复的事情交给了编译器。
在编译器编译阶段，对于模版函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。
假如主函数代码如下
int main()
{
int x1 = 1;
int y1 = 32;
Swap(x1, y1);
return 0;
}
int 类型推演
处理代码为
void Swap(int& xxxx, int& yyyy)
{
int temp = xxxx;
xxxx = yyyy;
yyyy = temp;
}
假如主函数内容如下
int main()
{
char x2 = 11;
char y2 = 33;
Swap(x2, y2);
return 0;
}char类型推演
处理代码为
void Swap(char& xxxx, char& yyyy)
{
char temp = xxxx;
xxxx = yyyy;
yyyy = temp;
}当用 double 类型使用函数模版时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码
4. 模版函数的实例化
用不同类型的参数使用函数模版时，称为函数模版的实例化。模版参数实例化分为：隐式实例化和显式实例化。
(1). 隐式实例化
让编译器根据实参推演模板参数的实际类型
#include<iostream>
using namespace std;
template <typename T>
T Add(const T& left, const T& right)
{
return left + right;
}
int main()
{
int a1 = 10, a2 = 11;
double d1 = 11.11, d2 = 7.007;
Add(a1,d1 );
Add(a2, d2);
return 0;
}上述代码不能通过编译，因为在编译期间，当编译器看到该实例化时，需要推演其实参类型
通过实参a1将T推演为int ，通过实参d1将T推演为double类型，但模版参数列表中只有一个T，编译器无法确定此处到底该将T确定为int或double类型而报错
注意：在模版中，编译器一般不会进行类型转换操作，因为一旦转换出问题，编译器就需要背黑锅
此时有两种解决方法：1. 用户手动强制类型转换 2. 使用显式实例化
Add(a1,(int)d1);
Add((double)a2,d2);(2.) 显式实例化
在函数名后的<>中指定模版参数的实际类型
int main()
{
int a1 = 10, a2 = 11;
double d1 = 11.11, d2 = 7.007;
Add<int>(a1,d1 );
Add<double>(a2, d2);
return 0;
}如果类型不匹配，编译器会尝试进行隐式类型转换，如果无法转换成功编译器将会报错。
5. 模版参数的匹配原则
一个非模版函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数
如以下代码
#include<iostream>
using namespace std;
template <typename T>
T Add(const T& left, const T& right)
{
return left + right;
}
int Add(const int& x, const int& y)
{
return (x + y) * 10;
}
int main()
{
int a1 = 10, a2 = 11;
double d1 = 11.11, d2 = 7.007;
cout << Add(1, 2) << endl;
cout << Add<int>(2, 2) << endl;
}其结果为
我们发现，与若与非模板函数匹配，编译器不需要特化
若显式实例化则调用编译器特化的Add版本
对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板中产生一个实例。如果模板可以产生一个具有更好匹配的函数，那么将选择模板
#include<iostream>
using namespace std;
int Add(const int& x, const int& y)
{
return (x + y) * 10;
}
template <typename T1,class T2>
T2 Add(const T1& left, const T2& right)
{
return left + right;
}
int main()
{
int a1 = 10, a2 = 11;
double d1 = 11.11, d2 = 7.007;
cout << Add(1, 2) << endl;
cout << Add(1, 2.1) << endl;
return 0;
}模板函数不允许自动类型转换，但普通函数可以进行自动类型转换
template <typename T1>
T1 Add(const T1& left, const T1& right)
{
return left + right;
}
int main()
{
int a1 = 10, a2 = 11;
double d1 = 11.11, d2 = 7.007;
char c1 = 'a';
Add(1, 2.1);
Add(d1, c1);
}第一个Add函数 2.1不会自动转换为int类型，1也不会自动转换为double(或float)
第二个同理 d1不会自动转化为char .......
而普通函数可以
#include<iostream>
using namespace std;
int Add(const int& x, const int& y)
{
return (x + y) * 10;
}
int main()
{
float a=10.11;
int a1 = 10, a2 = 11;
double d1 = 11.11, d2 = 7.007;
char c1 = 'a';
Add(1, 2.1);
Add(d1, c1);
}第一个Add函数2.1 自动进行了类型转换变为int类型
第二个Add函数的d1 自动类型转换变为了int类型，c1也转化为了int类型
三. 类模板
1. 类模板的定义格式
template <class T1,class T2,.....class Tn>
class 类模板名
{
//类内成员定义
};
如下代码
#include<iostream>
#include<cstring>
using namespace std;
template <typename T>
class Stack
{
public:
Stack(size_t capacity = 4)
:_arr(new T[capacity])
,_capacity(capacity)
,_size(0)
{
}
void Push(const T& data)
{
if (_size == _capacity)
{
T* tmp = new T [_capacity*2];
memcpy(tmp, _arr, sizeof(T)*_size);
delete[] _arr;
_arr = tmp;
_capacity *= 2;
}
_arr[_size++] = data;
}
T Top()
{
return _arr[_size-1];
}
~Stack()
{
delete[] _arr;
_arr = nullptr;
_size = _capacity = 0;
}
private:
T* _arr;
size_t _capacity;
size_t _size;
};而类的成员函数要在类外实现时需要注意
再写一个模板，因为类上面的模版只针对类内
假如 将Push类内声明，类外定义，代码如下
class Stack
{
public:
Stack(size_t capacity = 4)
:_arr(new T[capacity])
,_capacity(capacity)
,_size(0)
{
}
void Push(const T& data);
T Top()
{
return _arr[_size-1];
}
~Stack()
{
delete[] _arr;
_arr = nullptr;
_size = _capacity = 0;
}
private:
T* _arr;
size_t _capacity;
size_t _size;
};
template <typename T>
void Stack<T>::Push(const T& data)
{
if (_size == _capacity)
{
T* tmp = new T[_capacity * 2];
memcpy(tmp, _arr, sizeof(T) * _size);
delete[] _arr;
_arr = tmp;
_capacity *= 2;
}
_arr[_size++] = data;
}
int main()
{
Stack<int> s1;
s1.Push(1);
cout << s1.Top() << endl;
s1.Push(5);
cout << s1.Top() << endl;
s1.Push(12);
cout << s1.Top() << endl;
s1.Push(11);
cout << s1.Top() << endl;
s1.Push(2);
cout << s1.Top() << endl;
s1.Push(3);
cout << s1.Top() << endl;
return 0;
}下面的模板参数 也可以不叫T ，这两个T实际上就是代号，为什么是Stack<T>:: ，可以看下一条模板的实例化
模板不建议，声明和定义分离到两个文件.h 和.cpp 会出现链接错误，具体原因后面会讲
2. 类模板的实例化
类模板实例化，与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可，类模板名字不是真正的类,而实例化的结果才是真正的类
//其中Stack是类名，Stack<int>、Stack<char>、Stack<double>才是类型
Stack<int> s1;
Stack<double> s2;
Stack<char> s3;四. STL的介绍
1. 什么是STL？
STL(standard template libaray-标准模板库): 是C++标准库的重要组成部分，不仅是一个可复用的组件库，而且是一个包罗数据结构与算法的软件框架。
2. STL的版本
- 原始版本
Alexander Stepanov、Meng Lee 在惠普实验室完成的原始版本，本着开源精神，他们声明允许 任何人任意运用、拷贝、修改、传播、商业使用这些代码，无需付费。唯一的条件就是也需要向原 始版本一样做开源使用。 HP 版本--所有STL实现版本的始祖。
- P.J.版本
由P. J. Plauger开发，继承自HP版本，被Windows Visual C++采用，不能公开或修改，缺陷：可读 性比较低，符号命名比较怪异。
- RW版本
由Rouge Wage公司开发，继承自HP版本，被C+ + Builder 采用，不能公开或修改，可读性一 般。
- SGI版本
由Silicon Graphics Computer Systems，Inc公司开发，继承自HP版 本。被GCC(Linux)采用，可 移植性好，可公开、修改甚至贩卖，从命名风格和编程 风格上看，阅读性非常高。
3. STL的六大组件
这篇文章就写到这里啦，喜欢点一下赞吧~~
(๑′ᴗ‵๑)Ｉ Lᵒᵛᵉᵧₒᵤ❤
