int compare(const string&s1,const string&s2)
{if(s1<s2)return -1;if(s1>s2)return 1;return 0;
}int compare(const double&s1,const double&s2)
{if(s1<s2)return -1;if(s1>s2)return 1;return 0;
}

这两个函数参数类型不同，函数体是相同的，如果针对不同类型都要重载相应函数，这样就繁琐且代码复用性差,而且代码可维护性差。于是可以定义一个通用的函数模板，用来生成特定类型的函数版本。

模板定义以关键字template开始，后跟模板参数列表（用逗号分割的一至多个模板参数列表），用<>包围：

template<typename T>
int compare(const T&v1,const T&v2)
{if(v1<v2)return -1;if(v1>v2)return 1;return 0;
}

其中typename是模板类型参数，也可以用class（二者含义相同）

实例化函数模板：

当我们调用一个函数模板时，编译器在编译期用函数实参来为我们推断模板的实参，编译器用推断出的模板实参生成特定版本的函数称为实例化。

例如：

上面四个调用，因为类型不同，编译器便实例化出了四个不同的函数版本。

从反汇编可看出，调用了四个不同类型实参的函数：

 注意：string的类型是：

basic_string<char,char_traits<char>,allocator<char>>

因为string是basic_string类模板的一个实例：

namespace myspace {template <class T>class vector{private:T* _data;int _capacity;int _size;public:vector():_data(new T[10]),_capacity(10),_size(0){}~vector(){if (_data)delete[]_data;_size = _capacity = 0;}void push_back(const T& data);//...};template<class T>//若要在类外定义函数，需加上模板参数列表void vector<T>::push_back(const T& data){//..._data[_size++] = data;}}using namespace myspace;int main()
{//根据不同类型，编译器生成不同类型的类，称为类模板的实例化，//vector是类模板名字，vector<int>才是类型的名字vector<int>vi;vector<double>vd;return 0;
}

3.模板的语法

（1）非类型模板参数

模板参数分为：

类型模板参数：出现在模板参数列表中，跟在class或typename关键字后的名称

例如：template<class T>class vector;中的T

非类型模板参数： 出现在模板参数列表中，用特定类型名而非class或template关键字修饰，当模板被实例化时，非类型参数被用户提供的或编译器推断出的值替代，这些值必须是常量表达式。

例如：template<class T, size_t N = 10> class array ；

注意：

1. 浮点数、类对象以及字符串是不允许作为非类型模板参数的（可以是：整形（常量表达式），指针/左值引用（static对象或常量表达式））。

2. 非类型的模板参数必须在编译期就能确认结果。 

（2)   模板的特化

在原模板类的基础上，针对特殊类型所进行特殊化的实现方式。

例如：实现一个比较大小的函数模板

如上：当比较pa和pb时，返回的是false，原因是比较的是pa和pb地址的大小，pb的地址更小。

若要在比较指针时比较的是指针指向的内容，便可以用函数模板特化。

格式：template加<>,空<>表示将为所有模板参数提供实参，函数实参的类型必须与先前声明的模板中对应的类型匹配，比如原先const修饰的是v1，v2,改成指针类型时也得修饰指针本身，而不是修饰指针指向的内容。

如：

template <typename T>
bool Greater(const T& v1, const T& v2)
{return v1 > v2;
}//template <>
//bool Greater( const int*&p1,  const int*&p2)//error,参数类型不匹配
//{
//  return *p1 > *p2;
//}template <>
bool Greater( int* const &p1,  int* const &p2)
{return *p1 > *p2;
}//或者：
//template <>
//bool Greater(const int* const& p1, const int* const& p2)
//{
//  return *p1 > *p2;
//}//或者：函数名后跟<>,<>中指定需要特化的类型
//template <>
//bool Greater<int*>(int* const& p1, int* const& p2)
//{
//  return *p1 > *p2;
//}
int main()
{int a = 20;int b = 10;if (Greater(a, b))cout << "a is greater than b." << endl;int* pa = &a;int* pb = &b;if (Greater(pa, pb))cout << "pa->a is greater than pb->b." << endl;return 0;
}

结果：

函数模板特化的本质是实例化一个模板，而不是重载它，如果将上述函数再定义一个普通的非模板函数，参数类型等都匹配时，调用时编译器会选择非模板函数，一般直接给出非模板函数更方便，不用考虑模板参数类型匹配。

（3）模板的分离编译

将若干个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程称为分离编译。 所谓模板的分离编译，就是将其定义与声明分离，与内联函数相似，会产生链接错误。解决方法就是不这么干，或者在其定义的地方显式实例化。

例如：在.cpp中定义，在.h中声明，在另一个.cpp中使用，产生了链接错误

解决方法一：直接在.h定义

解决方法二：在定义的位置实例化（失去了模板的灵魂了）

总结：模板让代码复用性增强，增加了开发速度，也同时催生了STL的诞生。但是因为模板每次实例化都要产生一份代码，所以代码量是增加很多的，会导致编译时间增加。模板报错时往往报错信息也复杂，不容易定位错误信息。

4.STL简介