#4 C++模板

模板概念：

1.模板不是万能的
2.模板不能直接使用

---

函数模板的基本用法

1.模板语法

template< typename T>
函数声明或定义

2.具体使用实例

//交换整型函数
void swapInt(int& a,int& b)
{
	int temp;
	temp = a;
	a = b;
	b = temp;
}
//交换浮点型函数
void swapDouble(double& a,double& b)
{
	double temp = a;
	a = b;
	b = temp;
}
//各种类型的交换需要写多个函数，但是内容相似，此时可以使用函数模板
template<typename T>
void mySwap(T& a,T& b)
{
	T temp = a;
	a = b;
	b = temp;
}

int main()
{
	int a = 10,b = 20;
	//利用模板进行交换
	//1.自动识别类型
	mySwap(a,b);
	//2.显示指定类型
	mySwap<int>(a,b);
	cout<< "a = " << a << endl;	//10
	cout<< "b = " << b << endl;	//20;

	system("Pause");
	return 0;
}
	

3.总结

• 函数模板利用关键字 template
• 使用函数模板有两种方式：自动类型推导、显示指定类型
• 模板的目的是为了提高复用性，将类型参数化

---

函数模板注意事项

1.注意事项

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

2.具体使用实例

template<class T>
void mySwap(T& a,T&b)
{
	temp = a;
	a = b;
	b = temp;
}

void test01()
{
	int a = 10;
	char c = 'a';
	mySwap(a,c);	//程序会报错，因为a和c不是相同的数据类型
}

template<class T>
void func()
{
	cout << "func()" << endl;
}

void test02()
{
	func()	//程序报错，因为没有确定T的类型
	//若想程序正常运行，则应该给出T的类型，如下所示：
	func<int>()		//func()可以正常调用	
}

3.总结

• 使用模板时必须确定出通用数据类型T，并且能够推导出一致的类型

---

函数模板案例

1.案例描述：

• 利用函数模板封装一个排序的函数，可以对不同数据类型数组进行排序
• 排序规则从大到小、排序算法为选择排序
• 分别用char数组和int数组进行测试

2.具体实现：

#include<iostream>
using namespace std;

//交换函数模板
template<class T>
void mySwap(T& a,T& b)
{
	temp = a;
	a = b;
	b = temp;
}

//排序算法--选择排序
template<class T>
void mySort( T arr[], int len)
{
	for( int i = 0 ; i < len ; i++ )
	{
		max = i;
		for( int j = i+1 ; j < len-1 ; j++ )
		{
			if( a[max] < a[j] )
			{
				max = j;
			}
		if( max!= i )
		{
			mySwap(arr[i],arr[max];
		}
	}

//提供打印数组模板
template<class T>
void printArr(T arr[], int len )
{
	for(int i = 0; i<len ; i++)
	{
		cout << arr[i] << " " << endl ;
	}
}

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

void test02()
{
	//测试int
	int intArr[] = 78536;
	int num = sizeof(intArr)/sizeof(int);
	mysort(intArr[],num);
	printArr(intArr[],num);
}

int main()
{
	test01();
	test02();

	system(pause);
	return 0;
}
	

---

普通函数和函数模板的区别

1.区别：

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

2.示例：

#include<iostream>
using namespace std;

//普通函数
int myAdd01(int a,int b)
{
	return a+b ;
}

//函数模板
template<class T>
T myAdd02(T a, T b)
{
	return a + b;
}

void test01()
{
	int a = 10;
	int b = 20;
	char c = 'c';
	//隐式类型转换
	cout << myAdd01(a, c) << endl;

	//自动类型推导
	//myAdd02(a, c);

	//显示指定类型
	cout << myAdd02<int>(a, c) << endl;
}

int main()
{
	test01(); 

	system("pause");
	return 0;
}

---

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

1.调用规则如下：

• 如果函数模板和普通函数都可以实现，优先调用普通函数
• 可以通过空模板参数列表来强制调用函数模板
• 函数模板也可以发生重载
• 如果函数模板可以产生更好的匹配，优先调用函数模板

2.示例：

#include<iostream>
using namespace std;

void myPrint(int a, int b)
{
	cout<<"普通函数"<<endl;
}

template<class T>
void myPrint(T a, T b)
{
	cout<<"函数模板"<<endl;
}

void test01()
{
	int a = 10;
	int b = 20;

	myPrint(a,b);	//普通函数 
}

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

---

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

1.类模板中成员函数和普通类中成员函数创建时机是有区别的

• 普通类中的成员函数一开始就可以创建
• 类模板中的成员函数崽调用时才创建

2.示例：

#inclde<iostream>
using namespace std;

class Person1
{
public:
	void showPerson01()
	{
		cout<<"Person1 show"<<endl;
	}
};

class Person2
{
public:
	void showPerson02()
	{
		cout<<"Person2 show"<<endl;
	}
};

template<class T>
class myClass
{
public:
	//虚拟类型 -- 未知
	T obj;

	//类模板中的成员函数
	void func01()
	{
		obj.showPerson01();
	}

	void func02()
	{
		obj.showPerson02();
	}
};

void test01()
{
	MyClass<Person1> m;
	m.func1();
	//m.func2();
}

int main()
{
	test01();

	system("Pause");
	return 0;
}

---

类模板对象做函数参数

1.学习目标：

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

一共有三种传入方式：

1. 指定传入的类型 — 直接显示对象的数据类型(最常用)
2. 参数模板化 — 将对象中的参数变为模板进行传递
3. 整个类模板化 — 将这个对象类型模板化进行传递

2.示例：

#include<iostream>
using namespace std;
#include<string>

template<class T1,class T2>
class Perosn
{
public:
	Person(T1 name,T2 age)
	{
		m_Name = name;
		m_Age = age;
	}

	void showPerson()
	{
		cout<<"姓名："<<this->m_Name<<"\t年龄:"<<this->m_Age<<endl;
	}

	T1 m_Name; 
	T2 m_Age;
};

// 1. 指定传入的类型  ---  直接显示对象的数据类型
void printPerson01(Person<string,int>&p)
{
	p.showPerson();
}

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

// 2. 参数模板化  ---  将对象中的参数变为模板进行传递
template<class T1,class T2>
void printPerson02(Perosn<T1,T2)&p)
{
	p.showPerson();
	cout<<"T1的类型:"<<typeid(T1).name()<<"\tT2的类型:"<<typeid(T2).name<<endl;
}

void test02()
{
	Perosn<string,int)p("猪八戒",94);
	printPerson02(p);
}

template<class T>
void printPerson03(T &p)
{
	p.showPerson();
	cout<<"T的数据类型为："<<typeid(T).name<<endl;
}

void test03()
{
	Person<string,int>p("唐僧",18);
	printPerson03(p);
}

int main()
{
	test01();
	test02();
	test03();

	system("pause");
	return 0;
}

---

类模板与继承

1.当类模板碰到继承时，需要注意以下几点：

• 当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类T的类型
• 如果不指定，编译器无法给子类分配内存
• 如果想灵活指定父类中T的类型，子类也需变为类模板

2.示例：

#include<iostream>
using namespace std;

template<class T>
class Base
{
	T m;
};

//1. 当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类T的类型
class Son1:public Base<int>
{

};

void test01()
{
	Son1 s1;
}

//2. - 如果想灵活指定父类中T的类型，子类也需变为类模板
template<class T1,class T2>
class Son2:public Base<T2>
{
	SOn2()
	{
		cout<<"T1的类型为："<<typeid(T1).name<<endl;		//int
		cout<<"T2的类型为："<<typeid(T2).name<<endl;		//char
	}
	T1 obj;
};

void test02()
{
	Son2<int char>s2;
}

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

3.总结：
如果父类是类模板，子类需要指定出父类T的类型

---

类模板成员函数类外实现

1.学习目标：能够掌握类模板中成员函数类外实现
2.示例：

#include<iostearm>
using namespace std;

template<class T1,class T2>
class Person
{
public:
	Person(T n,T a);
//	{
//		this->m_Name = n;
//		this->m_Age = a;
//	}

	void showPerson();
//	{
//		cout<<"姓名："<<this->m_Name<<"\t年龄:"<<this->m_Age<<endl;
//	}

private:
	T m_Name;
	T m_Age;
};

template<class T1,class T2>
Person<T1, T2>::Person（T1 name ,T2 age）
{
	this->m_Name = n;
	this->m_Age = a;
}

template<class T1,class T2>
Person<T1, T2>::showPerson()
{
	cout<<"姓名："<<this->m_Name<<"\t年龄:"<<this->m_Age<<endl;
}

void test()
{
	Person<string,int>("Tom",20);
	p.showPerson();
}

int main()
{
	test();

	system("Pause");
	return 0;
}

---

类模板分文件编写

1.学习目标：

• 掌握类模板成员函数分文件编写产生的问题以及解决方法

2.问题：

• 类模板中成员函数创建时机是在调用阶段，导致分文件编写时链接不到

3.解决：

• 解决方法1：直接包含cpp源文件
• 解决方法2：将声明和实现写到同一个文件中，并更改后缀名为.hpp，hpp是约定的名称，并不是强制

4.示例：

person.hpp中代码：

#pragma once
#include <iostream>
using namespace std;
#include <string>

template<class T1, class T2>
class Person {
public:
	Person(T1 name, T2 age);
	void showPerson();
public:
	T1 m_Name;
	T2 m_Age;
};

//构造函数 类外实现
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age) {
	this->m_Name = name;
	this->m_Age = age;
}

//成员函数 类外实现
template<class T1, class T2>
void Person<T1, T2>::showPerson() {
	cout << "姓名: " << this->m_Name << " 年龄:" << this->m_Age << endl;
}

类模板分文件编写.cpp中代码

#include<iostream>
using namespace std;

//#include "person.h"
#include "person.cpp" //解决方式1，包含cpp源文件

//解决方式2，将声明和实现写到一起，文件后缀名改为.hpp
#include "person.hpp"
void test01()
{
	Person<string, int> p("Tom", 10);
	p.showPerson();
}

int main() {

	test01();

	system("pause");

	return 0;
}

---

类模板与友元类

1.全局函数类内实现 - 直接在类内声明友元即可
全局函数类外实现 - 需要提前让编译器知道全局函数的存在

2.示例：

#include<iostream>
using namespace std;
#include<string>

//提前让编译器知道Person存在
template<class T1,class T2>
class Person;

//类外实现
//加空模板参数列表
//如果全局函数是类外实现，需要让编译器提前知道这个函数的存在
template<class T1,class T2>
void printPerson2(Person<T1,T2> p)
{
	cout<<"姓名："<<p.m_Name<<"年龄："<<p.m_Age<<endl;
}

//通过全局函数打印Person信息
template<class T1,class T2>
class Person
{
	//全局函数类内实现
	friend void printPerson(Person<T1,T2> p)
	{
		cout<<"姓名："<<p.m_Name<<"年龄："<<p.m_Age<<endl;
	}
	
	//全局函数类外实现
	//加空模板参数列表
	friend void printPerson2<>(Person<T1,T2> p)；

public:
	Person(T1 name,T2 age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}

private:	
	T1 m_Name;
	T2 m_Age;
};



//1.全局函数在类内实现
void test01()
{
	Person<string,int>p("Tom",29);
	p.printPerson();
}

//2.全局函数在类外实现
void test02()
{
	Person<string,int>p("Jerry",34);
	p.printPerson2();
}

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

---

类模板案例–数组类封装

需求分析

1. 可以对内置数据类型以及自定义数据类型的数据进行存储
2. 讲数组中的数据存储到堆区
3. 构造函数中可以传入数组的容量
4. 提供对应的拷贝构造函数以及operator=防止浅拷贝问题
5. 提供尾插法和尾删法对数组中的数据进行增加和删除
6. 可以提供下标的方式访问数组中的元素
7. 可以获取数组中当前元素个数和数组的容量