- 1. 泛型编程
- 2. 函数模板
- 3. 类模板
1. 泛型编程
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;
}
......
可以发现这些代码都过于冗余大部分都重复,有没有什么办法给这么多代码简化一下呢
使用函数重载虽然可以实现,但是有一下几个不好的地方:
2. 函数模板
2.1 函数模板概念
2.2 函数模板格式
template<typename T>
void Swap( T& left, T& right)
{
T temp = left;
left = right;
right = temp;
}
有了他上面冗余的函数就可以退出历史的舞台了
模板它会自己去调用相应的函数
这种只需要改变一个变量类型的函数,逻辑如果都差不多就可以使用模板来做
底层函数由编译器生成,模板需要生成什么编译器就对函数进行实例化
注意:typename是用来定义模板参数关键字,也可以使用class(切记:不能使用struct代替class) ,现阶段class和typename目前是等价的
2.3 函数模板的原理
2.4 函数模板的实例化
这里x和y俩个都是整形的是可以运行的
这里俩个都是浮点型的这俩个也都是可以的
第一种方法就是:强转
这里转成不同的类型结果不同,这里会出项精度丢失
第二种就是显示实例化
但是这俩种方式就不行都存在数据丢失的问题比较鸡肋
最好用的应该是这样写,用auto来当返回值
template<class T1,class T2>
auto Add(const T1& x, const T2& y)
{
return x + y;
}
int main()
{
int x = 3;
double y = 4.6;
cout << Add(x, y) << endl;
return 0;
}
2.5 模板参数的匹配原则
// 专门处理int的加法函数
int Add(int left, int right)
{
return left + right;
}
// 通用加法函数
template<class T>
T Add(T left, T right)
{
return left + right;
}
void Test()
{
Add(1, 2); // 与非模板函数匹配,编译器不需要特化
Add<int>(1, 2); // 调用编译器特化的Add版本
}
// 专门处理int的加法函数
int Add(int left, int right)
{
return left + right;
}
// 通用加法函数
template<class T1, class T2>
T1 Add(T1 left, T2 right)
{
return left + right;
}
void Test()
{
Add(1, 2); // 与非函数模板类型完全匹配,不需要函数模板实例化
Add(1, 2.0); // 模板函数可以生成更加匹配的版本,编译器根据实参生成更加匹配的Add函
数
}
3. 模板函数不允许自动类型转换,但普通函数可以进行自动类型转换
这里可以理解为有 现成的函数就用现成的函数,没有现成的函数在去通过模板来实例化
3. 类模板
下面这里是一个栈
typedef int DataType;
struct Stack
{
void Init(size_t capacity)
{
_array = (DataType*)malloc(sizeof(DataType) * capacity);
if (nullptr == _array)
{
perror("malloc申请空间失败");
return;
}
_capacity = capacity;
_size = 0;
}
void Push(const DataType& data)
{
// 扩容
_array[_size] = data;
++_size;
}
DataType Top()
{
return _array[_size - 1];
}
void Destroy()
{
if (_array)
{
free(_array);
_array = nullptr;
_capacity = 0;
_size = 0;
}
}
DataType* _array;
size_t _capacity;
size_t _size;
};
这个栈我想存int 这里typedef就是int 想double就double,但是这里会出现一个问题,没有办法同时存int 和double
这里的栈的逻辑和上面的函数一样,逻辑都一样就只是数据类型不一样
会用模板以后就可以和typedef说再见了
template<class T>
class Stack
{
public:
Stack(size_t capacity=4)
{
_array = (T*)malloc(sizeof(T) * capacity);
if (nullptr == _array)
{
perror("malloc申请空间失败");
return;
}
_capacity = capacity;
_size = 0;
}
void Push(const T& data)
{
_array[_size] = data;
++_size;
}
T Top()
{
return _array[_size - 1];
}
void Destroy()
{
if (_array)
{
free(_array);
_array = nullptr;
_capacity = 0;
_size = 0;
}
}
private:
T* _array;
size_t _capacity;
size_t _size;
};
int main()
{
Stack<int> st1;
Stack<double>st2;
return 0;
}
这里模板必须显示实例化,模板不建议声明和定义分离,就是分为俩个文件,会出现链接错误