实验3 模板
模版的特点
- 模版不可以直接使用,只是作为一个框架
- 模版的通用并不是万能的
函数模版
建立一个通用函数,其函数返回值类型和形参类型可以不具体制定,用一个虚拟的类型来代表
语法:template <typename T>
声明一个模版,告诉编译器后面代码中紧跟着的T不要报错,T是一个通用数据类型
template<typename T>
void mySwap(T &a, T &b)
{
T temp = a;
a = b;
b = temp;
}
void test01()
{
int a = 10;
int b = 20;
//利用函数模版交换
//1、自动类型推导
mySwap(a, b);
//2、显示指定类型
mySwap<int>(a, b);
}
一般模板函数
template<typename T>
int compare(const T& left, const T& right)
{
if (left < right)
{
return -1;
}
if (right < left)
{
return 1;
}
return 0;
}
compare<int>(10, 20);
特化函数模版
-
使用模板特化时,必须要先有基础的模板函数(就是上面第一个模板函数)
-
使用特化模板函数时格式有要求:
1.template 后直接跟<> 里面不用写类型
2.函数名<特化类型>(特化类型 参数1, 特化类型 参数2 , …) 在函数名后跟<>其中写要特化的类型 -
特化的函数的函数名,参数列表要和原基础的模板函数相同,避免不必要的错误
template<>
void compare() {
cout << "特化函数模板调用 " << endl;
}
compare();
函数模板的注意事项:
- 自动类型推导,必须推导出一致的数据类型T才可以使用
- 模板必须要确定出T的数据类型,才可以使用
普通函数与函数模板的区别:
- 普通函数调用时可以发生自动类型转换(隐式类型转换)
- 函数模版调用时,如果利用自动类型推导,不会发生隐式类型转换
- 如果利用显示指定类型的方式,可以发生隐式类型转换
普通函数和函数模版调用的规则:
- 如果普通函数和函数模版都可以实现,优先调用普通函数
- 可以通过空模版参数列表来强调调用函数模版
myPrint<>(a, b);
- 函数模版也可以发生重载
- 如果函数模版可以产生更好的匹配,优先调用函数模版
模版的局限性
模版并不是万能的,有些特定的数据类型,需要用具体化的方法去做特殊实现
函数模版总结
既然选择使用了函数模版,就不要写普通函数,避免二义性
类模版
类模版实例
#include <iostream>
#include <string.h>
using namespace std;
//类模版
template<class NameType, class AgeType>
class Person
{
public:
Person(NameType name, AgeType age)
{
this->m_name = name;
this->m_age = age;
}
NameType m_name;
AgeType m_age;
}
//调用
void test01()
{
Person<string,int>p1("ljw",20);
}
void main()
{
test01();
system("pause");
return 0;
}
类模版中的成员函数并不是一开始就创建的,而是在调用的时候才创建
类模版对象做函数参数
//1、指定传入类型
void PrintPerson1(Person<string,int>&p)
{
p.showPerson();
}
void test01()
{
Person<string,int>p1("ljw",20);
PrintPerson1(p1);
}
//2、参数模版化
template<class T1, class T2>
void PrintPerson2(Person<T1, T2>&p);
{
p.showPerson();
}
void test02()
{
Person<string,int>p2("Jeffrey",19);
PrintPerson2(p2);
//3、整个类模版化
template<class T>
void PrintPerson3(T &p)
{
p.showPerson();
)
void test03()
{
Person<string,int>p3("Jeffrey",19);
PrintPerson3(p3);
}
类模版与继承
当类模版碰到继承时,应该注意以下几点:
- 当子类继承父类的一个类模版时,子类在声明的时候,要指定出父类中T的类型
- 如果不指定,编译器无法给子类分配内存
- 如果想灵活指定出父类T的类型,子类也需要变为类模版
template<class T>
class Base
{
T m;
};
class Son:public Base<int>//必须指定一个类型
{};
template<class T1, class T2>
class Son2:public Base<T2>
{
};
void test02()
{
Son2<int, char> child1;
}
构造函数的类外实现
template<class T1, class T2>
class Person
{
public:
Person(T1 name, T2 age);
T1 name;
T2 age;
}
template<class T1, class T2>
Person<T1,T2>::Person(T1 name, T2 age)
{
this->name=name;
this->age=age;
}
模板类(AutoPtr)
构造函数
template<class T>
AutoPtr<T>::AutoPtr(T* pData)
{
m_pData = pData;
m_nUser = new int(1);
}
析构函数
template<class T>
void AutoPtr<T>::decrUser()
{
‐‐(*m_nUser);
if ((*m_nUser) == 0) {
delete m_pData;
m_pData = 0;
delete m_nUser;
m_nUser = 0;
}
}
拷贝构造函数
template<class T>
AutoPtr<T>& AutoPtr<T>::operator=(const AutoPtr<T>& h)
{
decrUser();
m_pData = h.m_pData;
m_nUser = h.m_nUser;
(*m_nUser)++;
}
等号、->、*等运算符重载
template<class T>
AutoPtr<T>& AutoPtr<T>::operator=(const AutoPtr<T>& h)
{
decrUser();
m_pData = h.m_pData;
m_nUser = h.m_nUser;
(*m_nUser)++;
}
类模版自写案例
实现功能
- 可以对内置数组类型以及自定义数据类型的数据进行存储
- 将数据中的数据类型存储到堆区
- 构造函数中可以传入数组的容量
- 提供对应的拷贝构造函数以及operator=防止浅拷贝问题(有堆区数据就要考虑浅拷贝)
- 提供尾插法和尾删法对数组中的数据进行增加和删除
- 可以通过下标的方式访问数组中的元素
- 可以获取数组中当前元素个数和数组的容量
//有参构造 参数是数组的容量
MyArray(int capacity)
{
//cout << "MyArray有参构造" << endl;
this->m_Capacity = capacity;
this->m_Size = 0;
this->pAddress = new T[this->m_Capacity];
}
MyArray(const MyArray& arr)
{
//cout << "MyArray拷贝构造" << endl;
this->m_Capacity = arr.m_Capacity;
this->m_Size = arr.m_Size;
//深拷贝,防止系统自动生成拷贝构造函数中的this->pAddress = arr.pAddress;
this->pAddress = new T[arr.m_Capacity];
//将arr中的数据拷贝过来
for (int i = 0; i < this->m_Size; i++)
{
this->pAddress[i] = arr.pAddress[i];
}
}
MyArray& operator=(const MyArray& arr)
{
//cout << "MyArray的operator=" << endl;
//先判断原来堆区是否有数据,如果有先释放
if (this->pAddress != NULL)
{
delete[] this->pAddress;
this->pAddress = NULL;
this->m_Capacity = 0;
this->m_Size = 0;
}
//深拷贝
this->m_Capacity = arr.m_Capacity;
this->m_Size = arr.m_Size;
this->pAddress = new T[arr.m_Capacity];
for (int i = 0; i < this->m_Size; i++)
{
this->pAddress[i] = arr.pAddress[i];
}
return *this;
}
//尾插法
void Push_Back(const T& val)
{
//判断容量是否等于大小
if (this->m_Capacity == this->m_Size)
{
return;
}
this->pAddress[this->m_Size] = val;//在数组末尾插入数据
this->m_Size++;//更新数组大小
}
//尾删法
void Pop_Back()
{
if (this->m_Size == 0)
{
return;
}
this->m_Size--;
}
//通过下标方式访问数组中的元素
T operator[](int index)
{
return this->pAddress[index];
}
//返回数组容量
int getCapacity()
{
return this->m_Capacity;
}
//返回数组大小
int getSize()
{
return this->m_Size;
}
//析构函数
~MyArray()
{
//cout << "MyArray析构函数" << endl;
if (this->pAddress != NULL)
{
delete[] this->pAddress;
this->pAddress = NULL;//指向空,防止野指针
}
}
//MyArray元素
private:
T* pAddress;//指针指向堆区开辟的真实数组
int m_Capacity;//数组总容量
int m_Size;//数组实时大小