泛型编程
如何实现一个通用的交换函数呢，利用c++函数重载的方式
void Swap(int& left, int& right)
{
int temp = left;
left = right;
right = temp;
}
void Swap(double& left, double& right)
{
double temp = left;
left = right;
right = temp;
}
void Swap(char& left, char& right)
{
char temp = left;
left = right;
right = temp;
}
......
使用函数重载虽然可以实现，但是有一下几个不好的地方：
- 重载的函数仅仅是类型不同，代码复用率比较低，只要有新类型出现时，就需要用户自己增加对应的函数
- 代码的可维护性比较低，一个出错可能所有的重载均出错
那能否告诉编译器一个模子，让编译器根据不同的类型利用该模子来生成代码呢
泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础
函数模板
函数模板概念
函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。
函数模板格式
关键字：template
注意：typename是用来定义模板参数关键字，也可以使用class(切记：不能使用struct代替class)
格式：
template<class T1> 或者 template<typename T1>
如果有多个，可以这样写：
template<typename T1,typename T2, typename T3>
注意：
- 是用
<>尖括号 扩起来的 - 尖括号里面的是定义的类型
看看具体事例：
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;
}
类模板
观察下面的代码：
#include<iostream>
using namespace std;
// 栈类
typedef int DataType;
class Stack
{
public:
//默认构造：
Stack(size_t capacity = 3)
{
_array = (DataType*)malloc(sizeof(DataType) * capacity);
if (NULL == _array)
{
perror("malloc 申请空间失败！！！");
return;
}
_capacity = capacity;
_size = 0;
}
//压栈
void Push(DataType data)
{
//CheckCapacity();
_array[_size] = data;
_size++;
}
//析构
~Stack()
{
cout << "~Stack()" << endl;
free(_array);
_array = nullptr;
_size = _capacity = 0;
}
private:
DataType* _array;
int _capacity;
int _size;
};
int main()
{
Stack st;
return 0;
}
思考一下，如果 我要定义一个栈st 我希望它是double类型的，我只需要把typedef int DataType 中的 int 换成 double 就可以了
但是，如果我想定义2个栈，st1 是 int类型，st2 是double 类型，阁下又该怎么办？
Stack st1; // int 类型
Stack st2; //double类型
这个时候就要用到内类型 了。
#include<iostream>
using namespace std;
template<class T>
class Stack
{
public:
//默认构造：
Stack(size_t capacity = 3)
{
_array = (T*)malloc(sizeof(T) * capacity);
if (NULL == _array)
{
perror("malloc 申请空间失败！！！");
return;
}
_capacity = capacity;
_size = 0;
}
//压栈
void Push(const T data)
{
_array[_size] = data;
_size++;
}
//析构
~Stack()
{
cout << "~Stack()" << endl;
free(_array);
_array = nullptr;
_size = _capacity = 0;
}
private:
T* _array;
int _capacity;
int _size;
};
int main()
{
Stack<int> st1; // int 类型
Stack<double> st2; // double 类型
return 0;
}
再来看下面的例子：
我们可以这样改：
#include<iostream>
using namespace std;
template<class T>
T Add(const T& left, const T& right)
{
return left + ringht;
}
int main()
{
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;
}
