C++学习——提高编程之模板（1）

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

提示：这里可以添加本文要记录的大概内容：

例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。

---

提示：以下是本篇文章正文内容，下面案例可供参考

针对C++泛型编程和STL技术做详细讲解，

1 模板

1.1 模板的概念

模板就是建立通用的模具，大大提高复用性
C++提供的是函数模板和类模板

1.2 函数模板

作用：建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表

语法：
template《typename T》
函数声明或定义

（ template——声明创建模板
typename——表明其后面的符号是一种数据类型，可以用class代替
T——通用的数据类型，名称可以替换，通常为大写字母）

template<typename T>	
//声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用数据类型
void mySwap(T &a,T &b)
{
	T temp=a;
	a=b;
	b=temp;
}

//利用函数模板交换
//有两种方式使用函数模板
//1、自动类型推导
//2、显示指定类型
void test1()
{
	int a=10;
	int b=20;
//1、自动类型推导
//mySwap(a,b);

//2、显示指定类型
	mySwap<int>(a,b);
	cout<<"a="<<a<<endl;
	cout<<"b="<<b<<endl;
}

注意：
自动类型推导，必须推导出一致的类型T，才可以使用
模板必须要确定出T的数据类型，才可以使用

1、自动类型推导必须推导出一致的类型T，才可以使用
void test01()
{
	int a=10;
	int b=20;
	char c='c';
	//mySwap(a,b); //正确
	//mySwap(a,c);//错误，推导不出一致的T类型
}
2、模板必须要确定出T的数据类型，才可以使用
template<typename T>
void func()
{
	cout<<"func调用"<<endl;	
}
void02()
{
	//func();	//没有指定出T的数据类型,所以错误
	func<int>();	//√
}

实例：
实现对数组进行排序的函数，规则：从大到小
算法：选择 测试：char数组、int数组

#include<iostream>
using namespace std;

template<typename T>
void mySwap(T &a,T &b)
{
	T temp=a;
	a=b;
	b=temp;
}
//排序
template<class T>
void mySort(T arr[],int len)
{
	for(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)	//交换max和i的元素
		{
			mySwap(arr[max],arr[i]);
		}
	}
	
}

//打印数组的模板
template<typename T>
void printArray(T arr[],int len)
{
	for(int i=0;i<len;i++)
	{
		cout<<arr[i]<<"" ;
	}
	cout<endl;
}
void test01()
{
	char charArr[]="bacfde";
	int num=sizeof(charArr)/sizeof(char);
	mySort(charArr,num);
}

1.2.1 普通函数与函数模板

普通函数与函数模板尽量不要同时出现

普通函数与函数模板的区别：

1、普通函数调用时可以发生自动类型转换（隐式类型转换）
2、函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
3、如果利用显示指定类型的方式，可以发生隐式类型转换

普通函数与函数模板的调用规则

1、如果函数模板和普通函数都可以实现，优先调用普通函数
（如果普通函数只有声明没有实现，也不会调用函数模板，而是会报错）
2、可以通过空模板参数列表来强制调用函数模板
3、函数模板也可以发生重载
4、如果函数模板可以产生更好的匹配，优先调用函数模板

void myPrint(int a,int b)
{
	cout<<"调用普通函数"<<endl;
}
template<typename T>
void myPrint(T a,T b)
{
	cout<<"调用模板"<<endl;
}
//函数重载
template<typename T>
void myPrint(T a,T b,T c)
{
	cout<<"调用重载模板"<<endl;
}
void test01()
{
	int a=10;
	int b=20;
	//2、通过空模板参数列表，强制调用函数模板
	myPrint<>(a,b);
	
	myPrint(a,b,100);	//	3、只能调用函数模板重载，因为只有它匹配

	// 4、如果函数模板可以产生更好的匹配，优先调用函数模板
	char c1='a';
	char c2='b';
	myPrint(c1,c2);	//会调用函数模板，因为不需要隐式类型转换
}

1.2.2 模板的局限

有些特定数据类型，需要用具体化的方式做特殊实现

//利用具体化的person的版本实现代码，具体化优先调用
template<> bool myCompare(Person &a,Person &b)
{
if(p1.m_namep2.m_name && p1.m_agep2.m_age)
return true;
else
return false;
}

class Person
{
public:
	Person(string name,int age)
	{
		this->m_name=name;
		this->m_age=age;
	}
	string m_name;
	int m_age;
};
template<typename T>
bool myCompare(T &a,T &b)
{
	if(a==b)					//可以重载==号来解决
		return true;
	if(a!=b)
		return false;
}
//利用具体化的person的版本实现代码，具体化优先调用
template<> bool myCompare(Person &a,Person &b)
{
	if(p1.m_name==p2.m_name && p1.m_age==p2.m_age)
		return true;
	else
		return false;
}
void test01()
{
	int a=10;
	int b=20;
	bool ret=myCompare(a,b);
	if(ret)
		cout<<"a==b"<<endl;
	else
		cout<<"a!=b"<<endl;
}
void test02()
{
	Person p1("Tom",10);
	Person p2("Tom",10);
	bool ret=myCompare(p1,p2);
	if(ret)
		cout<<"p1==p2"<<endl;
	else
		cout<<"p1!=p2"<<endl;
}

1.3 类模板

类模板作用：
建立一个通用类，类中的成员 数据类型可以不具体制定，用一个虚拟的类型代表

语法：
template《typename T》
类

//类模板
template<class NameType,class AgeType>
class Person
{
public:
	Person(NameType name,AgeType age)
	{
		this->m_name=name;
		this->m_age=age;
	}
	void showperson()
	{
		cout<<"Name:"<<this->m_name<<"Age:"<<m_age<<endl;
	}
	NameType m_name;
	AgeType m_age;
};
void test01()
{
	Person<string,int>p1("小米",10);
}

1.4 类模板和函数模板的区别

1、类模板没有自动类型推导的使用方式
2、类模板在模板参数列表中可以有默认参数

template<class NameType,class AgeType>	//class NameType,class AgeTyp模板参数列表
class Person
{
public:
	Person(NameType name,AgeType age)
	{
		this->m_name=name;
		this->m_age=age;
	}
	void showperson()
	{
		cout<<"Name:"<<this->m_name<<"Age:"<<m_age<<endl;
	}
	NameType m_name;
	AgeType m_age;
};
	//1、类模板没有自动推导的使用方式
void test01()
{
	//Person p1("小米",10);	//错误，无法用自动类型推导
	Person<string,int>p1("小米",10);
}

//2、类模板在模板参数列表中可以有默认参数
//template<class NameType,class AgeType>改为
//template<class NameType,class AgeType =int>
void test01()
{
	Person<string>p1("小米",10);
}

1.5 类模板中成员函数创建时机

普通类中的成员函数一开始就可以创建
类模板中的成员函数在调用时才创建（因为不确定数据类型）

1.6类模板对象做函数参数

类模板实例化出的对象，向函数传参的方式

一共有三种传入方式：
1、指定传入的类型——直接显示对象的数据类型
2、参数模板化——将对象中的参数变为模板进行传递
3、整个类模板化 ——将这个对象类型模板化进行传递

template<class T1,class T2>
class Person
{
public:
	Person(T1 name,T2 age)
	{
		this->m_name=name;
		this->m_age=age;
	}
	void showperson
	{
		cout<<"姓名："<<this->m_name<<"年龄："<<this->m_age<<endl;
	}
	T1 m_name;
	T2 m_age;
};

//1、指定传入类型
void printPerson1(Person<string,int>&p)
{
	p.showperson();
}
void test01()
{
	Person<string,int>p("Tom",100);
	printPerson1(p);
}

//2、参数模板化
template<class T1,class T2>
void printPerson2(Person<T1,T2>&p)
{
	p.showperson();
	cout<<"T1类型："<<typeid(T1).name()<<endl	//可以查看T1的类型
}
void test02()
{
	Person<string,int>p("Alice",90);
	printPerson2(p);
}

//3、整个类模板化
template<class T>
void printPerson3(T &p)
{
	p.showperson();
	cout<<"T1类型："<<typeid(T).name()<<endl	//T
}
void test03()
{
	Person<string,int>p("mar",40);
	printPerson3(p);
}