函数模板与类模板

1、模板的基本概念

  有一个求最大值的函数，如果比较两个数大小，这两个数可以是int类型，也可以是float，或者是double，当我们不知道这两个数具体是什么类型的时候，这时候需要重复定义，三个函数，用来处理求最大值的两个数可能是这三种类型。

int Swap(int a, int b)
{
   return a > b ? a : b;
}
float Swap(float a, flaot b)
{
   return a > b ? a : b;
}
double Swap(double a, double b)
{
   return a > b ? a : b;
}

这时候模板起到了作用，有了模板只需要写一遍求两数最大值的函数就可以了，模板作用于函数功能相同，但是处理不同类型的数据比较方便，避免了重复定义函数。

2、函数模板及模板函数

使用函数模板之前先要声明函数模板，然后将其类型参数具体化形成相应的模板函数，最后才能调用模板函数

函数模板声明格式：
template <class 类型参数名1， class 类型参数名2 ，…> //声明函数模板
返回类型 函数名 (形参表) //可以开始使用模板函数了
{
    //函数体
}
或
template <Typename类型参数名1， typename 类型参数名2 ，…> //声明函数模板
返回类型 函数名 (形参表) //可以开始使用模板函数了
{
    //函数体
}
其中，template是声明函数模板的关键字，class和typename其后表示类型参数。
class 类型参数名1， class 类型参数名2 ，…成为类型形参表

代码如下：

#include <iostream>
using namespace std;
template <class ElemType>  //声明一个函数模板
ElemType Max(ElemType a, ElemType b) //模板函数
{
	return a > b ? a : b;
}

int main()
{
	cout << Max(1, 2) << endl; 
	/* 
	    正确 因为1和2都是相同的整型
		通过Max(1,2)调用过去后，由于1和2都是确定的类型是int
		所以将ElemType全部替换成int
		代码变为:
		int Max(int a, int b) //模板函数
		{
			return a > b ? a : b;
		}
	*/



	//cout << Max(1, 2.0) << endl;
	/*
	    错, 1是int类型， 2.0是实型类型，传过去时候，不知道将ElemType到底替换成int 还是实型
	*/
	//改为
	cout << Max<float>(1, 2.0) << endl;
	/*
	   这时候原本的Max(1, 2.0)改为
	   Max<float>(1, 2.0)那么吧ElemType全部替换成float类型
	   代码变为:
		float Max(float a, float b) //模板函数
		{
			return a > b ? a : b;
		}
	*/
	system("pause");
	return 0;
}

用函数模板声明template < class ElemType >
template声明模板的关键字，然后后面跟着<> 尖括号，尖括号里面是形参表，
里面是class ElemType ，其中ElemType是自己起的名字，可以是T1, T2, A, B，等等，
这个类似于现实生活中打麻将的癞子一样，用自己起的名字ElemType代替任何牌，这里的替换是替换任何数据类型，具体替换什么类型关键看调用函数传过来的参数是什么，就替换什么类型。
第一种：Max(1, 2)这种，1和2都是int类型，那么传过去后，吧所有的ElemType全部替换成int类型
第二种：Max< float >(1.0, 2)这种，直接告诉是float类型，那么传过去后，吧所有的ElemType全部替换成float类型

3、重载函数模板

3.1、示例一

#include <iostream>
#include <cstring>
using namespace std;
template <typename ElemType>
ElemType Max(ElemType a, ElemType b)
{
	return a > b ? a : b;
}
char* Max(char* a,char* b) 
{
	return strcmp(a, b) > 0 ? a : b;
} 

int main()
{
	cout << Max(1.3, 5.6) << endl;
	cout << Max("China", "American") << endl;
	system("pause");
	return 0;
}

3.2、示例二

main.cpp：

#include <iostream>
#include "MyArray.h"

using namespace std;
int main()
{
	int a[] = { 1,5,4,3 };
	cout << "数组a的最大元素的值为: " << max(a, 4) << endl;
	cout << "2和3的最大值为: " << max(2, 3) << endl;
	cout << "2和3和8的最大值为: " << max(2, 3, 8) << endl;
	return 0;
}

MyArray.h

#pragma once
template <class Elemplate>
Elemplate max(Elemplate& a, Elemplate& b)
{
	return a > b ? a : b;
}

template <class Elemplate>
Elemplate max(Elemplate a, Elemplate b, Elemplate c)
{
	Elemplate d;
	d = a > b ? a : b;
	return d > c ? d : c;
}

template <class Elemplate>
Elemplate max(Elemplate* a, int n)
{
	Elemplate m = a[0];
	for (int i = 1; i < n; i++)
		if (m < a[i]) m = a[i];

	return m;
}

3、类模板

类模板的声明：
template < class 类型参数名1， 类型参数名2， …>
class 类名
{
    //类体
}；
或
template < typename 类型参数名1， 类型参数名2， …>
class 类名
{
    //类体
}；

类模板不但可以在类内定义也可以在类外定义。
类外定义格式：
template < class 类型参数名1， 类型参数名2， …>
返回值类型 类名 < 类型参数名1， 类型参数名2 > :: 成员函数(形参表)
{
    //函数体
}
或
template < typename 类型参数名1， 类型参数名2， …>
返回值类型 类名 < 类型参数名1， 类型参数名2 > :: 成员函数(形参表)
{
    //函数体
}
代码示例

#include <iostream>
using namespace std;
template <typename ElemType>
class Array
{
private:
	ElemType* elem;
	int size;
public:
	Array(int size)
	{
		this->size = size;
		elem = new ElemType[size];
	}
	~Array() { delete elem; }
	void SetElem(ElemType e, int i);
	ElemType GetElem(int i) const;
};

//类外声明
template <typename ElemType> void Array<ElemType>::SetElem(ElemType e, int i)
{
	if (i < 0 || i >= size)
	{
		cout << "错误" << endl;
		exit(0);
	}
	elem[i] = e;
}

template <typename ElemType> ElemType Array<ElemType> ::GetElem(int i) const
{
	if (i < 0 || i >= size)
	{
		cout << "错误" << endl;
		exit(0);
	}
	return elem[i];
}
int main()
{
	int a[] = { 1,2,3,4,5,6 };
	int n = 6;
	Array<int> obj(n);
	for (int i = 0; i < n; i++)
		obj.SetElem(a[i], i);

	for (int i = 0; i < 6; i++)
		cout << obj.GetElem(i) << " ";
	    
	putchar('\n');
	system("pause");
	return 0;
}