模板
- [1、模板 --- 泛型编程(广泛类型的编程)](#1、模板 --- 泛型编程(广泛类型的编程))
- 2、函数模板
-
- [2.1 函数模板概念](#2.1 函数模板概念)
- [2.2 函数模板格式](#2.2 函数模板格式)
- [2.3 C++库里面有swap函数，可以直接用](#2.3 C++库里面有swap函数，可以直接用)
- [2.4 函数模板的实例化](#2.4 函数模板的实例化)
- 3、类模板
1、模板 --- 泛型编程(广泛类型的编程)
cpp
//泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。
//模板分为两类：函数模板和类模板2、函数模板
2.1 函数模板概念
cpp
// 函数模板代表了一个函数家族，该模板函数与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。2.2 函数模板格式
cpp
// template<typename T1,typename T2, .....,typename Tn> 【typename只可以换成class】【一般只有一个模板参数】
//template<typename T> //模板参数（模板类型）---类似函数参数（参数对象）
//typename后面类型名字T是随便取的，Ty\K\V ,一般是大写字母或单词首字母大写
// T代表是一个模板类型（虚拟类型）
template<typename T>
void Swap(T& left,T& right)
{
T tmp = left;
left = right;
right = tmp;
}
int main()
{
int i = 1, j = 2;
double x = 1.1, y = 2.2;
char m = 'A'; char n = 'B';
Swap(i,j);
Swap(x,y);
Swap(m,n);
return 0;
}
// 函数模板的实例化: 根据实参的类型 产生 相应类型的函数。2.3 C++库里面有swap函数，可以直接用
cpp
int main()
{
int i = 1, j = 2;
double x = 1.1, y = 2.2;
char m = 'A'; char n = 'B';
swap(i,j);
swap(x,y);
swap(m,n);
return 0;
}2.4 函数模板的实例化
cpp
// 用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为:隐式实例化和显式实例化。
template<typename T>
T Add(const T& left,const T& right)
{
return left + right;
}
template<class T>
T* Func(int n)
{
T* a = new T[n];
return a;
}
int main()
{
Add(1,2);
//Add(1.1,2); //推演实例化矛盾，报错
//(1)隐式示例化解决（编译器自动推演）
cout<< Add(1, 2) <<endl;
cout << Add((int)1.1, 2) << endl;
cout << Add(1.1, (double)2) << endl;
//(2)显示实例化
cout << Add<int>(1.1, 2) << endl;
cout << Add<double>(1.1, 2) << endl;
//必须显示实例化才能调用
Func<A>(10);
return 0;
}3、类模板
cpp
template<typename T>
class Stack
{
public:
//构造函数
Stack(size_t capacity = 4)
:_a(nullptr)
, _top(0)
, _capacity(0)
{
if (capacity > 0)
{
_a = new T[capacity];
_capacity = capacity;
_top = 0;
}
}
~Stack()
{
delete[] _a;
_a = nullptr;
_top = _capacity = 0;
}
void Push(const T& x) // 插入的是T类型的数据
{
if (_top == _capacity)
{
size_t newCapacity = _capacity == 0 ? 4 : _capacity * 2;
//1、开新空间
T* tmp = new T[newCapacity];
if (_a)
{
//2、拷贝数据
memcpy(tmp, _a, sizeof(T) * _top);
//3、释放旧空间
delete[] _a;
}
_a = tmp;
_capacity = newCapacity;
}
//插入数值
_a[_top] = x;
++_top;
}
void Pop()
{
assert(_top > 0);
--_top;
}
bool Empty()
{
return _top == 0;
}
const T& Top()
{
assert(_top > 0);
return _a[_top - 1]; //数据放在堆区的，Top的栈帧销毁了之后，仍然存在
}
private:
T* _a;
size_t _top;
size_t _capacity;
};
//模板不支持分离编译；即：声明放在.h , 定义放在 .cpp
//模板在同一个文件中，声明和定义是可以分离的。
int main()
{
try
{
//类模板都是显示实例化
//虽然它们用了一个类模板，但是Stack<int>, Stack<char> 是两个类
Stack<int> st1;
st1.Push(1);
st1.Push(2);
st1.Push(3);
st1.Push(4);
st1.Push(5);
//栈顶的数据不允许修改，这儿试验一下而已
/*st1.Top()++;
st1.Top() *= 2;*/
while (!st1.Empty())
{
cout << st1.Top() << " ";
st1.Pop();
}
cout << endl;
}
catch (const exception& e)
{
cout << e.what() << endl;
}
return 0;
}