函数模板可以像普通函数一样被调用。再调用者看来，函数模板的类型参数像是一种通用数据类型。

2、函数模板的编译原理

  函数模板是具有类型参数的函数。类型参数是表示数据类型的参数，可指代任意一种实际数据类型。编译器再编译到函数模板的调用语句时，根据位置对应关系从实参数据类型推导出类型参数所指代的数据类型，然后按照函数模板自动生成一个该类型的函数定义代码。不同类型实参的函数模板调用语句将生成不同类型的重载函数。函数模板将数据类型参数化，调用时会呈现参数多态性。

3、函数模板的声明

  跟普通函数一样函数模板也需要先定义后调用的原则。如果函数模板定义再调用后，或定义再其他程序文件中，则应先声明后调用。函数模板的声明语法形式为：

  template <类型参数列表>

  函数类型 函数名(形参参数列表)；

  或

  template <类型参数列表>函数类型 函数名(形参参数列表)；

#include
using namespace std;
template   //函数模板Max定义声明
T Max(T x,T y);
int main()
{
    cout << Max(5,10) <  //函数模板Max定义
T Max(T x,T y)   
{
    return(x>y?x:y);
}

  程序员再编程时可以灵活使用模板技术。在定义多个重载函数时可以考虑是否将他们定义成一个函数模板，这样可以凝练函数代码。再定义单个函数时也可以考虑定义成函数模板，这样可以提高函数代码的可重用性。对于调用函数模板的程序员而言，函数模板和普通函数没有什么区别。唯一不同的时函数模板可以处理不同类型的数据。

二、类模板

  应用模板技术，也可以将一组功能相同但所处理数据类型不同的类凝练成一个类模板。编译时，再由编译器按照类模板自动生成针对不同数据类型的类定义代码。

1、类模板的定义和使用

  定义类模板的语法形式：

  template <类型参数列表>

  class 类名 //类声明部分

  {

    类成员声明

  }

  //类实现部分：所有类外定义的函数成员，必须按如下的语法形式将它们定义成函数模板

  template <类型参数列表>

  函数类型 类名<类型参数名列表>::函数名(形式参数列表)

  { 函数体 }

类模板的几点语法细则：

• 定义类模板以关键字template开头
• 类型参数列表可以声明一个或多个类型参数，每个类型参数以"typename 类型参数名"或"class 类型参数名"的形式声明，类型参数之间用逗号”，“隔开。
• 类模板定义的其余部分，包括类名、类成员声明以及类实现部分，它们和普通类的定义形式基本相同。
• 定义类模板的函数成员，如果再类内定义(内联函数),其语法形式和普通类的函数成员没区别；如果再类外(即类实现部分)定义，则必须按照函数模板的语法形式来定义，并且还要再函数名前面加“类名<类型参数名列表>::”限定。
• 使用typename和class声明的类型参数可视为一种新的数据类型，类型参数是表示数据类型的参数，再使用类模板时可被替换成任意数据类型。

定义好的类模板可以像普通类一样被用来定义对象。使用类模板定义对象时，需要明确给出类模板中类型参数所指代的实际数据类型。其语法形式如下：类模板名 <实际数据类型列表> 对象名1，对象名2 .....;

类模板语法示例：

#include
using namespace std;
template  //类模板A
class A  //类声明部分
{
    private: //声明两个私有数据成员
        T a1;
        int a2;
    public:
        A(T p1,int p2) //定义构造函数
        { a1 = p1; a2 = p2}
        void Show() //显示数据成员
        { cout << a1 <<","< o1(10.5,6); //double型对象
    o1.Show(); //显示：10.5，6
    cout< o2(10,6); //int型对象
    o2.Show(); //显示：10，6
    cout<

#include
using namespace std;
template  //类模板A
class A  //类声明部分
{
    private: //声明两个私有数据成员
        T a1;
        int a2;
    public:
        A(T p1,int p2); //定义构造函数
        void Show(); //显示数据成员
        T Sum(); //求数据成员的和
};
//类实现部分
template 
A ::A(T p1,int p2) 
{ a1 = p1; a2 = p2}
template 
void A ::Show() 
{ cout << a1 <<","<
T A ::Sum()
{return (T)(a1+a2); }
int main()
{
    //用类模板定义对象
    A  o1(10.5,6); //double型对象
    o1.Show(); //显示：10.5，6
    cout< o2(10,6); //int型对象
    o2.Show(); //显示：10，6
    cout<

2、类模板的编译原理

  当定义到类模板定义对象语句时，编译器将根据所给出的实际数据类型来取代类型参数T。例如A <double>o1(10.5,6); 编译时将类模板中类类型参数绑定到某个具体数据类型的过程，称为类模板的实例化。实例化所生成的类称为类模板的实例类。实例类是一个普通的类，可以用来定义对象。

  类模板编译原理：类模板是具有类型参数的类。类型参数是表示数据类型的参数，可指代任意实际数据类型。编译器在编译到使用类模板定义对象语句时，将首先按照所给定的实际数据类型对类模板进行实例化，生成一个实例类。最终，编译器使用实例类来定义所需要的对象。

3、类模板的继承和派生

  类模板可以被继承，派生出新类。以类模板为基类定义派生类，可以在派生时实例化，也可以继续定义派生类模板。

1、定义实例化派生类

  定义实例化派生类就是在派生类继承基类的时候将类型参数赋值，此时派生类对基类进行实例化。

#include
using namespace std;
template  //类模板基类Base
class Base  //类声明部分
{
    private: //声明私有数据成员
        T a;
    public:
        Base(T x) { a=x; }
        void Show() { cout<< "a="< //公有继承基类模板Base，派生时实例化
{
    private: //声明新增数据成员
        int b;
    public:
        //注意派生类构造函数写法
        Derived(double p1,int p2):Base(p1) { b=p2; } 
        //新增函数成员Show
        void Show() { Base ::Show(); cout<< "b="<

#include
using namespace std;
template  //类模板基类Base
class Base  //类声明部分
{
    private: //声明私有数据成员
        T a;
    public:
        Base(T x) { a=x; }
        void Show() { cout<< "a="< //新增类型参数TT
class Derived:public Base //公有继承基类模板Base,定义派生类模板
{
    private: //声明新增数据成员
        TT b;
    public:
        //注意派生类构造函数写法
        Derived(T p1,TT p2):Base(p1) { b=p2; } 
        //新增函数成员Show
        void Show() { Base ::Show(); cout<< "b="< obj(10.5,6);//定义派生类Derived对象obj
    obj.Show(); //显示结果：a=10.5,b=6
    return 0;
}