C++学习笔记（7）---模板，函数模板、类模板

1 模板

C++泛型编程（模板）和STL技术，C++两种模板机制：函数模板和类模板

1.1 模板的概念---建立通用的模具，大大提高复用性

1.2 模板的特点---（1）模板不可以直接使用，只是一个框架；（2）模板的通用并不是万能的

1.3 函数模板---类型通用化

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

2、语法：template<typename T>//函数声明或定义

解释：template---声明创建模板；typename---其后面的符号是一种数据类型，可以用class代替

T----通用的数据类型，名称可以替换，通常为大写字母

//--------练习一：函数模板--------------
//函数模板声明，告诉后面编译器T是一个通用数据类型
template<typename T>
void MySwap(T &a,T &b)
{
	T temp=a;
	a=b;
	b=temp;
}
int main()
{
	int a=10;
	int b=20;
	//利用函数模板交换，有两种方式使用
	//1、自动类型推导
	//MySwap(a,b);
	//2、显示指定类型
	MySwap<int>(a,b);

	cout<<"a="<<a<<endl;
	cout<<"b="<<b<<endl;
	return 0;
}

总结：（1）函数模板利用关键字template;

（2）使用函数模板两种方式：自动类型推导、显示指定类型；

（3）模板的目的是为了提高复用性，将类型参数化；

3、函数模板的注意事项

（1）自动类型推导，必须推导出一致的数据类型T才可以使用；

（2）模板必须要确定出T的数据类型，才可以使用；

4、函数模板案例

//------练习二：函数模板练习，整型/字符型数组排序-----------
template<typename T>//函数模板声明
void MySwap(T &a,T &b)
{
	T temp=a;
	a=b;
	b=temp;
}
template<typename T>//函数模板声明
void MyShow(T Array[],int length)
{
	for(int i=0;i<length;i++)
	{
		cout<<Array[i]<<" ";
	}
	cout<<endl;
}
template<typename T>//函数模板声明
void MySort(T Array[],int length)
{
	//选择排序，从大到小
	for(int i=0;i<length;i++)
	{
		int Max=i;
		for(int j=i+1;j<length;j++)
		{
			if(Array[j]>Array[Max])
			{
				Max=j;
			}
		}
		if(Max!=i)
		{
			MySwap(Array[i],Array[Max]);
		}
	}
}
int main()
{
	//char array[]="defgabc";//g f e d c b a
	//int length=sizeof(array)/sizeof(char);
	int array[]={1,2,3,4,5,6};//6 5 4 3 2 1
	int length=sizeof(array)/sizeof(int);
	MySort(array,length);
	//cout<<length<<endl;
	MyShow(array,length);
	return 0;
}

5、普通函数与函数模板的区别

（1）普通函数调用时，可以发生自动类型转换（隐式类型转换）；

（2）函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换；

（3）如果利用显示指定类型的方式，可以发生隐式类型转换；（值传递）

总结：建议使用显示指定类型的方式，调用函数模板，因为可以自己确定通用类型T

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

（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;
}
int main()
{
	int a=100;
	int b=200;
	//1、都可情况下，优先普通函数调用
	MyPrint(a,b);//调用普通函数
	//2、空模板参数列表强制调用函数模板
	MyPrint<>(a,b);//调用函数模板
	//3、函数模板重载
	MyPrint(a,b,100);//调用重载函数模板
	//4、更好匹配，优先调用函数模板
	MyPrint('a','b');//调用函数模板，普通函数需要隐式类型转换
	return 0;
}

总结：既然提供了函数模板，最好不要提供普通函数，否则容易出现二义性；

7、模板的局限性---模板的通用性并不是万能的

template<tpyename T>
void f(T a,T b)
{
    a=b;//赋值操作，如果传入的a和b是一个数组，就无法实现
}
template<class t>
void f(T a,T b)
{
    if(a>b){……}//如果T为自定义数据类型Person，也无法正常运行
}

因此C++为了解决这种问题，提供模板的重载，可以为这些特定的类型提供具体化的模板。

//---------练习四：模板的局限性------------------------
template<typename T>
bool MyCompare(T &a,T &b)
{
	if(a==b)return true;
	else return false;
}
void test01()
{
	int a=1;
	int b=20;
	bool ret=MyCompare(a,b);
	if(ret)
		cout<<"相等"<<endl;
	else
		cout<<"不相等"<<endl;
}
class Person
{
public:
	Person(string name,int age)
	{
		this->m_Age=age;
		this->m_Name=name;
	}
	int m_Age;
	string m_Name;
};
//利用具体化Person的版本实现代码，具体化优先调用
template<> bool MyCompare(Person &p1,Person &p2)
{
	if(p1.m_Age==p2.m_Age && p1.m_Name==p2.m_Name)
		return true;
	else
		return false;
}
void test02()
{
	Person P1("Tom",20);
	Person P2("To",20);
	bool ret=MyCompare(P1,P2);
	if(ret)
		cout<<"相等"<<endl;
	else
		cout<<"不相等"<<endl;
}
int main()
{
	test02();
	return 0;
}

总结：（1）利用具体化的模板，可以解决自定义类型的通用化；

（2）学习模板并不是为了写模板，而是在STL中能够运用系统提供的模板；

1.4 类模板

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

2、语法：template<typename T>

template---声明创建模板；typename---其后面的符号是一种数据类型，可以用class代替

T---通用的数据类型，名称可以替换，通常为大写字母

//-----------练习五：类模板----------------------
//创建一个通用类,不指定成员数据类型
template<class NameType,class AgeType>
class Person
{
public:
	Person(NameType name,AgeType age)
	{
		this->m_Name=name;
		this->m_Age=age;
	}
	void Show()
	{
		cout<<"姓名："<<this->m_Name<<endl;
		cout<<"年龄："<<this->m_Age<<endl;
	}
	NameType m_Name;
	AgeType m_Age;
};
void test()
{
	Person<string,int>P1("Tom",20);
	P1.Show();
}
int main()
{
	test();
	return 0;
}

总结：类模板和函数模板语法相似，在声明模板template后面加类，此类称为类模板

3、类模板与函数模板区别

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

template<class NameType,class AgeType=int>//默认参数类型
……
Person <string>P1("Tom",20);//不指定第二个数据类型也可以，会采用默认参数的数据类型int

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

（1）普通类中成员函数一开始就可以创建；（2）类模板中的成员函数在调用时才创建；

5、类模板对象做函数参数

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

（1）指定传入的类型---直接显示对象的数据类型；

（2）参数模板化---将对象中的参数变为模板进行传递；

（3）整个类模板化---将这个对象类型模板化进行传递；

//------------练习六：类模板对象做函数参数---------
template<class TypeName,class TypeAge>
class Person
{
public:
	Person(TypeName name,TypeAge age)
	{
		this->m_Name=name;
		this->m_Age=age;
	}
	TypeName m_Name;
	TypeAge m_Age;
};
//1、------------指定传入的类型-----------
void Show01(Person<string,int>&p)
{
	cout<<"姓名："<<p.m_Name<<" 年龄："<<p.m_Age<<endl;
}
void test01()
{
	Person<string,int>P1("张三",18);
	Show01(P1);
}
//2、----------------参数模板化--------------
template<class TypeName,class TypeAge>
void Show02(Person<TypeName ,TypeAge>&p)
{
	cout<<"姓名："<<p.m_Name<<" 年龄："<<p.m_Age<<endl;
}
void test02()
{
	Person<string,int>P1("李四",20);
	Show02(P1);
}
//3、-----------------整个类模板化----------------
template<class T>
void Show03(T &p)
{
	cout<<"姓名："<<p.m_Name<<" 年龄："<<p.m_Age<<endl;
}
void test03()
{
	Person<string,int>P1("王五",22);
	Show03(P1);
}
int main()
{
	test03();
	return 0;
}

总结：使用广泛的是第一种：指定传入的类型，23都是函数模板与类模板配合使用，过于复杂

6、类模板与继承---注意事项

（1）当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中的T的数据类型；

如果不指定，编译器无法给子类分配内存；

（2）如果想灵活制定出父类中的T的数据类型，子类也需变成类模板；

//-------------练习七：类模板与继承-------------
template<class T>
class Base
{
public:
	T a;
};
class Son1:public Base<int>//指定父类数据类型T
{
public:
	int b;
};
template<class T1,class T2>//子类变成类模板
class Son2:public Base<T1>
{
public:
	Son2()//构造函数
	{
		cout<<"T1的类型为："<<typeid(T1).name()<<endl;//输出为int 
		cout<<"T2的类型为："<<typeid(T2).name()<<endl;//输出为char
	}
	T2 b;
};
void test()
{
	Son1 S1;
	Son2<int,char>S2;
}
int main()
{
	test();
	return 0;
}

7、类模板成员函数类外实现

//--------------练习八：类模板成员函数类外实现--------
template<class TypeName,class TypeAge>
class Person
{
public:
	Person(TypeName name,TypeAge age);
	void ShowPerson();//类内声明，类外实现
	TypeName m_Name;
	TypeAge m_Age;
};
template<class TypeName,class TypeAge>//类模板成员函数类外实现
Person<TypeName,TypeAge>::Person(TypeName name,TypeAge age)
{
	this->m_Name=name;
	this->m_Age=age;
}
template<class TypeName,class TypeAge>//类模板成员函数类外实现
void Person<TypeName,TypeAge>::ShowPerson()
{
	cout<<"姓名："<<this->m_Name<<" 年龄："<<this->m_Age<<endl;
}
void test()
{
	Person<string,int>P1("张三",20);
	P1.ShowPerson();
}
int main()
{
	test();
	return 0;
}

8、类模板分文件编写

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

解决：（1）直接包含.cpp源文件；

（2）将声明和实现写到同一个文件中，并更改后缀名为.hpp，hpp是约定的名称，并不是强制

9、类模板与友元

（1）全局函数类内实现-直接在类内声明友元即可；

（2）全局函数类外实现-需要提前让编译器知道全局函数存在；

//--------------练习九：类模板与友元-------------------
//全局函数类外实现，要提前知道这个类模板的存在
template<class TypeName,class TypeAge>
class Person;
//类外实现放前面
template<class TypeName,class TypeAge>
void Show(Person<TypeName,TypeAge>p)
{
	cout<<"类内实现---姓名："<<p.m_Name<<" 年龄："<<p.m_Age<<endl;
}
template<class TypeName,class TypeAge>
class Person
{
	//全局函数-----类内实现
	//friend void Show01(Person<TypeName,TypeAge>p)//此处为类模板传参，指定参数类型
	//{
	//	cout<<"类内实现---姓名："<<p.m_Name<<" 年龄："<<p.m_Age<<endl;
	//}
	//全局函数-----类外实现,类内声明
	//这个是普通函数的声明，要加空模板参数列表
	//如果全局函数类外实现，需要让编译器提前知道这个函数的存在
	friend void Show<>(Person<TypeName,TypeAge>p);//此处为类模板传参，指定参数类型
public:
	Person(TypeName name,TypeAge age)
	{
		this->m_Name=name;
		this->m_Age=age;
	}
private:
	TypeName m_Name;
	TypeAge m_Age;
};
//1、全局函数在类内实现
//void test01()
//{
//	Person<string,int>P1("张三",20);
//	Show01(P1);
//}
//2、全局函数类外实现，函数模板的函数实现

void test02()
{
	Person<string,int>P1("李四",22);
	Show(P1);
}
int main()
{
	test02();
	return 0;
}

总结：建议全局函数类内实现，用法简单，而且编译器可以直接识别；

10、类模板的案例---实现一个通用的数组类

（1）可以对内置数据类型以及自定义数据类型的数据进行存储；

（2）将数组中的数据存储到堆区；（3）构造函数中可以传入数组的容量；

（4）提供对应的拷贝函数以及operator=防止浅拷贝问题；

（5）提供尾插法和尾删法对数组中的数据进行增加和删除；

（6）可以用过下标方式访问数组元素；（7）获取数据中当前元素个数和数组

注意：这个案例代码有问题，没有解决

HEAP CORRUPTION DETECTED: after Normal block (#162) at0x00A9D600.
CRT detected that the application wrote to memory after end of heapbuffer.