---

C++ 模版

模板是C++支持参数化多态的工具，使用模板可以使用户为类或者函数声明一种一般模式，使得类中的某些数据成员或者成员函数的参数、返回值取得任意类型；模板是一种对类型进行参数化的工具。
　　通常有两种形式：函数模板和类模板；
　　函数模板：针对仅参数类型不同的函数；
　　类模板： 针对仅数据成员和成员函数类型不同的类。
注意：模板的声明或定义只能在全局，命名空间或类范围内进行。即不能在局部范围内进行。

1、 函数模版

　template <class 形参名，class 形参名，......> 返回类型 函数名(参数列表)
　{
            函数体
　}

1、其中template和class是关见字，class可以用typename 关见字代替，在这里typename 和class没区别,这里说名一下两个的区别和相同：
---- 在声明 template parameters（模板参数）时，class 和 typename 是可互换的。
---- 用 typename 去标识 nested dependent type names（嵌套依赖类型名），在 base class lists（基类列表）中或在一个 member initialization list（成员初始化列表）中作为一个 base class identifier（基类标识符）时除外，这种情况 class 和 typename是不可互换。
看看例子：

class MyArray 
{ 
public：
typedef int LengthType;
.....
}

template<class T>
void MyMethod( T myarr ) 
{ 
typedef typename T::LengthType LengthType; 
LengthType length = myarr.GetLength; 
}

这个时候typename的作用就是告诉c++编译器，typename后面的字符串为一个类型名称，而不是成员函数或者成员变量，这个时候如果前面没有
typename，编译器没有任何办法知道T::LengthType是一个类型还是一个成员名称(静态数据成员或者静态函数)，所以编译不能够通过。
2、 <>括号中的参数叫模板形参
模板形参和函数形参很相像，模板形参一般不能为空。为空的时候后面需要具解释这个用法特化处理。这里我们先介绍不为空的。
一但声明了模板函数就可以用模板函数的形参名声明类中的成员变量和成员函数，即可以在该函数中使用内置类型的地方都可以使用模板形参名。模板形参需要调用该模板函数时提供的模板实参来初始化模板形参，一旦编译器确定了实际的模板实参类型就称他实例化了函数模板的一个实例。

注意：对于函数模板而言不存在 h(int,int) 这样的调用，不能在函数调用的参数中指定模板形参的类型，对函数模板的调用应使用实参推演来进行，即只能进行 h(2,3) 这样的调用，或者int a, b; h(a,b)。
示例：

template <class T>
int compare(const T &left, const T&right)
{
    std::cout <<"in template<class T>..." <<std::endl;
    return (left - right);
}

2、 类模版

template<class  形参名，class 形参名，…>   class 类名     // 定义
{ ... };

类模板对象的创建：比如一个模板类A，则使用类模板创建对象的方法为A<int> m;
对于类模板，模板形参的类型必须在类名后的尖括号中明确指定。比如A<2> m;用这种方法把模板形参设置为int是错误的。
在类模板外部定义成员函数的方法为：
　　　　template<模板形参列表> 函数返回类型 类名<模板形参名>::函数名(参数列表){函数体}，
比如有两个模板形参T1，T2的类A中含有一个void h()函数，则定义该函数的语法为：
　　　　template<class T1,class T2> void A<T1,T2>::h(){}。
注意：当在类外面定义类的成员时template后面的模板形参应与要定义的类的模板形参一致。
示例：

#include <iostream>
#include <cstring>
#include <cmath>
// general version
template<class T>
class Compare
{
public:
    static bool IsEqual(const T& lh, const T& rh)
    {
        std::cout <<"in the general class..." <<std::endl;
        return lh == rh;
    }
};

3、 模版形参

有三种类型的模板形参：‘类型’形参，非类型形参和模板形参。类型不是指class定义的类，通过模版定义的<typename T>这些。

1、类型形参
类型模板形参：类型形参由关见字class或typename后接说明符构成，如template<class T> void h(T a){};其中T就是一个类型形参，类型形参的名字由用户自已确定。模板形参表示的是一个未知的类型。
注意：
对于函数模版：不能为同一个模板类型形参指定两种不同的类型，比如template<class T>void h(T a, T b){}，语句调用h(2, 3.2)将出错。
对于类模版：声明类对象为：A<int> a，比如template<class T>T g(T a, T b){}，语句调用a.g(2, 3.2)在编译时不会出错，有警告；当声明A<double> a,警告都不会有。

2、 非类型形参
1 、非类型模板形参：模板的非类型形参也就是内置类型形参，如template<class T, int a> class B{};其中int a就是非类型的模板形参。
2、 非类型形参在模板定义的内部是常量值。
3、 非类型模板的形参只能是整型，指针和引用。
4、 调用非类型模板形参的实参必须是一个常量表达式，即他必须能在编译时计算出结果。
常量表达式有:
-----1> 全局变量的地址或引用，全局对象的地址或引用const类型变量是常量表达式，可以用作非类型模板形参的实参。
----- 2> sizeof表达式的结果是一个常量表达式，也能用作非类型模板形参的实参。
5、当模板的形参是整型时调用该模板时的实参必须是整型的，且在编译期间是常量，比如template <class T, int a> class A{};如果有int b，这时A<int, b> m;将出错，因为b不是常量，如果const int b，这时A<int, b> m;就是正确的，因为这时b是常量。
6、非类型形参一般不应用于函数模板中，比如有函数模板template<class T, int a> void h(T b){}，若使用h(2)调用会出现无法为非类型形参a推演出参数的错误，对这种模板函数可以用显示模板实参来解决，如用h<int, 3>(2)这样就把非类型形参a设置为整数3。显示模板实参在后面介绍。
7、 非类型模板形参的形参和实参间所允许的转换
　　1、允许从数组到指针，从函数到指针的转换。如：template <int *a> class A{}; int c[1]; A<c> m;即数组到指针的转换
　　2、const修饰符的转换。如：template<const int *a> class A{}; int b; A<&b> m; 即从int *到const int *的转换。
　　3、提升转换。如：template<int a> class A{}; const short c=2; A<c> m; 即从short到int 的提升转换
　　4、整值转换。如：template<unsigned int a> class A{}; A<3> m; 即从int 到unsigned int的转换。
　　5、常规转换。
注意： 任何局部对象，局部变量，局部对象的地址，局部变量的地址都不是一个常量表达式，都不能用作非类型模板形参的实参。全局指针类型，全局变量，全局对象也不是一个常量表达式，不能用作非类型模板形参的实参。

补充：
类模板的默认模板类型形参：
1、可以为类模板的类型形参提供默认值，但不能为函数模板的类型形参提供默认值。函数模板和类模板都可以为模板的非类型形参提供默认值。
2、类模板的类型形参默认值形式为：template<class T1, class T2=int> class A{};为第二个模板类型形参T2提供int型的默认值。
3、类模板类型形参默认值和函数的默认参数一样，默认应该在后面，如果第一个设置默认，那么后面其他的都应该设置默认。
4、 在类模板的外部定义类中的成员时template 后的形参表应省略默认的形参类型。如： template<class T1, class T2=int> class A{public: void h();}; 外部函数 ：template<class T1,class T2> void A<T1,T2>::h(){}。

4、 模版特化

特化：为已有的模板参数进行一些使其特殊化的指定，使得以前不受任何约束的模板参数，或受到特定的修饰（例如const或者变成为了指针之类，甚至是经过别的模板类包装之后的模板类型）或完全被指定了下来。

分类：
------- 针对特化的对象不同，分为两类：函数模板的特化和类模板的特化。
函数模板的特化：当函数模板需要对某些类型进行特化处理，称为函数模板的特化。
类模板的特化：当类模板内需要对某些类型进行特别处理时，使用类模板的特化。
------- 特化整体上分为全特化和偏特化
全特化：全特化的类中的函数可以与模板类不一样。
偏特化：就是模板中的模板参数没有被全部确定，需要编译器在编译时进行确定。

注意： 模板函数只能全特化，没有偏特化（以后可能有）；模板类是可以全特化和偏特化的。

还是使用上面的示例：

// 一个模版函数
template <class T>
int compare(const T &left, const T&right)
{
    std::cout <<"in template<class T>..." <<std::endl;
    return (left - right);
}

// 一个特化的函数
template < >
int compare<const char*>(const char* left, const char* right)
{
    std::cout <<"in special template< >..." <<std::endl;

    return strcmp(left, right);
}

// 或者
template < >
int compare(const char* left, const char* right)
{
    std::cout <<"in special template< >..." <<std::endl;

    return strcmp(left, right);
}

函数模版的特化，当函数调用发现有特化后的匹配函数时，会优先调用特化的函数，而不再通过函数模版来进行实例化。

类模板的特化：与函数模板类似，当类模板内需要对某些类型进行特别处理时，使用类模板的特化。
类模板特化的几种类型：一是特化为绝对类型；二是特化为引用，指针类型；三是特化为另外一个类模板。

示例：

// 1、   特化为绝对类型
template<class T>
class Compare
{
public:
    static bool IsEqual(const T& lh, const T& rh)
    {
        std::cout <<"in the general class..." <<std::endl;
        return lh == rh;
    }
};
// 特化为 float类型
template<>
class Compare<float>
{
public:
    static bool IsEqual(const float& lh, const float& rh)
    {
        std::cout <<"in the float special class..." <<std::endl;

        return std::abs(lh - rh) < 10e-3;
    }
};

// 2 、 特化为指针或者引用类型
// 特化为T*指针
template<class T>
class Compare<T*>
{
public:
    static bool IsEqual(const T* lh, const T* rh)
    {
        return Compare<T>::IsEqual(*lh, *rh);
    }
};
// 除了T*, 我们也可以将T特化为 const T*, T&, const T&。

// 3、 特化为另外一个类模板
// 特化 任何其他的模版
template <class T1> 
struct SpecializedType
{
    T1 x1;
    T1 x2;
};
template <class T>
class Compare<SpecializedType<T> >
{
public:
    static bool IsEqual(const SpecializedType<T>& lh, const SpecializedType<T>& rh)
    {
        return Compare<T>::IsEqual(lh.x1 + lh.x2, rh.x1 + rh.x2);
    }
};

模版总结基本这么多！！！