C++模板

模板

函数模板

• 普通函数与函数模板的区别：
  1、普通函数会发生隐式类型转换
  2、函数模板在自动类型推导时不会发生隐式类型转换 在指定类型时会发生隐式类型转换
• 普通函数与函数模板的调用规则：
  1、都可以调用时优先调用普通函数
  2、可通过空模板参数列表 强制调用函数模板
  3、函数模板可以发生重载
  4、若函数模板能产生更好的匹配，优先调用函数模板

	void myPrint(int a,int b);
	template<class T>
	void myPrint(T a,T,b);

	char a='a',b='b';
	cout<<myPrint(a,b);   //调用模板

---

案例：冒泡排序

#include<iostream>
using namespace std;

//函数模板进行数组排序
//算法 选择排序
//测试char数组 int数组

//交换数据
template<typename T>
void mySwap(T &a,T &b)
{
	T temp;
	temp=a;
	a=b;
	b=temp;
}

//选择排序
template<typename T>
void mySort(T arr[],int len)
{
	for(int i=0;i<len;i++)
	{
		int max=i;
		for(int j=i+1;j<len;j++)
		{
			if(arr[max]<arr[j])
				max=j;   //更新最大值下标
		}
		if(max!=i)
			mySwap(arr[max],arr[i]);
	}
}

//打印输出模板
template<typename T>
void printArr(T arr[],int len)
{
	for(int i=0;i<len;i++)
	{
		cout<<arr[i]<<' ';
	}
	cout<<endl;
}

void test01()
{
	//测试char 数组
	char Arrchar[]={"abcdef"};
	int num=sizeof(Arrchar)/sizeof(char);
	mySort(Arrchar,num);
	printArr(Arrchar,num);
}

void test02()
{
	//测试int 数组
	int Arrint[]={3,5,2,1,7,9};
	int num=sizeof(Arrint)/sizeof(int);
	mySort(Arrint,num);
	printArr(Arrint,num);
}
int main()
{
	test01();
	test02();
	system("pause");
	return 0;
}

类模板

• 类模板与函数模板的区别：
  1、类模板没有自动类型推导,只能显示指定
  2、类模板可以有默认参数列表
  注：类模板中的成员函数不是一开始就创建的，在调用时才会创建

template<class NameType,class AgeType>
class Person
{
public:
	Person(NameType name,AgeType age)
	{
		this->m_Age = age;
		this->m_Name = name;
	}
	void showPerson()
	{
		cout<<"name:"<<this->m_Name<<"\t"<<"age:"<<this->m_Age<<endl;
	}

private:
	NameType m_Name;
	AgeType m_Age;
};

//void test()
//{
//	Person<string,int> p("mzz",23);
//	p.showPerson();
//}

• 类模板对象做函数参数：
  1、指定类型传入
  2、参数模板化
  3、整个类模板化

//1、指定类型传入
void printPerson01(Person<string, int>&p)
{
	p.showPerson();
}

void test01()
{
	Person<string, int>p("孙悟空",100);
	printPerson01(p);
}

//2、参数模板化
template<class NameType,class AgeType>
void printPerson02(Person<NameType,AgeType>&p)
{
	p.showPerson();
	cout<<"NameType的类型："<<typeid(NameType).name()<<endl;
	cout<<"AgeType的类型："<<typeid(AgeType).name()<<endl;
}

void test02()
{
	Person<string, int>p("孙悟空",100);
	printPerson02(p);
}

//3、整个类模板化
template<typename T>
void printPerson03(T &p)
{
	p.showPerson();
	cout<<"T的类型："<<typeid(T).name()<<endl;
}

void test03()
{
	Person<string, int>p("孙悟空",100);
	printPerson03(p);
}

---

案例：数组类封装
MyArray.hpp

//自己通用的数组类
#pragma once
#include<iostream>
using namespace std;

template<class T>
class MyArray
{
public:
	//有参构造
	MyArray(int capacity)
	{
		cout<<"有参构造调用"<<endl;
		this->m_Capacity=capacity;
		this->m_Size=0;
		this->pAddress=new T[this->m_Capacity];
	}

	//拷贝构造
	MyArray(const MyArray &arr)
	{
		cout<<"拷贝构造调用"<<endl;
		this->m_Capacity=arr.m_Capacity;
		this->m_Size=arr.m_Size;

		//深拷贝
		this->pAddress=new T[arr.m_Capacity];

		//将arr中的数据拷贝过来
		for(int i=0;i<arr.m_Size;i++)
		{
			this->pAddress[i]=arr.pAddress[i];
		}
	}

	//operator =防止浅拷贝问题  运算符重载
	MyArray& operator =(const MyArray &arr)
	{
		cout<<"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];

		//将arr中的数据拷贝过来
		for(int i=0;i<arr.m_Size;i++)
		{
			this->pAddress[i]=arr.pAddress[i];
		}
		return *this;
	}

	//析构函数
	~MyArray()
	{
		cout<<"析构函数调用"<<endl;
		//判断堆区是否有数据
		if(this->pAddress!=NULL)
		{
			delete []this->pAddress;
			this->pAddress=NULL;
		}
	}
private:
	//存储空间
	T *pAddress;
	//容量
	int m_Capacity;
	//大小
	int m_Size;
};

MyArray.cpp

#include<iostream>
using namespace std;
#include "MyArray.hpp"

void  test01()
{
	MyArray<int>arr1(5);

	MyArray<int>arr2(arr1);

	MyArray<int>arr3(100);
	arr3=arr1;
}

int main()
{
	test01();
	system("pause");
	return 0;
}

模板局限性：
通用性不是万能的 利用具体化模板可以解决自定义类型的通用化