第一次做心得总结，写的肯定不如其他编程大佬一样厉害，作为菜鸟本菜我会写的非常通俗易懂，个人觉得是自己的编程能力的提升吧，顺便复习学过的知识，和大家分享也会很快乐。

• 我们为什么要用模板？

  • 解决排序问题

不同类型的对象，排序时的不同是：比较两个对象的大小

• 两种解决方式

• 函数重载
  例如：
  sort (...classA...){......}
  sort（...classB...){......}
  分别写俩个同名函数 由编译系统函数调用时实参的类型，来确定实际执行的函数。

• 函数模板
  template <class T>

模板分类

1.函数模板

格式：
template<class 数据类型参数标识符1，…，class 数据类型参数标识符n>
<返回类型><函数名>(参数表)
{
函数体
}

2.类模板

格式：
template<class 形参名1, class 形参名2, ...class 形参名n>
class 类名{
...
};
接下来我们一一赘述吧~

• 函数模板：

像是一个带有类型参数的函数，编译程序会根据实际参数的类型确定参数的类型。(看不懂可以忽略这句话）
模板只是把多个重复的代码化简成单个!
举一个非常简单滴例子：

    #include <iostream>  
    using namespace std;  
      
    template<typename T, typename T2>  
    void sortArray(T *a, T2 num)  
    {  
        T tmp ;  
        int i, j ;  
        for (i=0; i<num; i++)  
        {  
            for (j=i+1; j<num; j++)  
            {  
                if (a[i] < a[j])  
                {  
                    tmp = a[i];  
                    a[i] = a[j];  
                    a[j] = tmp;  
                }  
            }  
        }  
    }  
      
    template<class T>  
    void pirntArray(T *a, int num)  
    {  
        int i = 0;  
        for (i=0; i<num; i++)  
        {  
            cout<<a[i]<<" ";  
        }  
        cout << endl;  
    }  
      
    int main()  
    {  
        int num = 0;  
        char a[] = "daddyyyyyyyy";  
        num = strlen(a);  
      
        cout << "排序之前" << endl;  
        pirntArray<char>(a, num);  
      
        sortArray<char, int>(a, num); //显示类型调用 模板函数 <>  
        cout << "排序之后" << endl;  
        pirntArray<char>(a, num);  
        cout<<"hello..."<< endl;  
        return 0;  
    }  

• 模板特化

当函数模板需要对某些类型进行特别处理，称为函数模板的特化
举个简单滴例子：
我们编写了一个泛化的比较程序

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

这可咋整哇！！它不支持char*(string)类型唉
不要怕！
我们可以对其进行特化，以让它支持两个字符串的比较,因此我们实现了如下的特化函数。

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

    return strcmp(left, right);
}

那整体该怎么写呢，给大家一个完整的代码参考吧~

template <typename T>//模板实例
int compare(T a,  T b)//比较了地址
{
    if (a < b)
        return -1;
    if (a>b)
        return 1;
    return 0;
}
template <>//模板特化    在模板实例之后
//特化的声明必须与特定的模板相匹配
//int compare<const char*>(char* p1, char*  p2)//error :不是函数模板的专用化
int compare<const char*>(const char* p1, const char*  p2)
{
    return strcmp(p1,p1);
}
int main()
{
    char* p1 = "abcd";
    char* p2 = "abce";
    const char* p3 = "abcd";
    const char* p4 = "abce";
    cout << compare(p1, p2) << endl;
    cout << compare(p3, p4) << endl;
    return 0;
}

• 模板重载（直接看代码吧）

template <typename T>
T Max(const T& a, const T& b)
{
    return a > b ? a : b;
}
template <typename T>
T Max(const T& a, const T& b, const T& c)//重载
{
    return Max(Max(a, b), c);
}
int main()
{
    Max(1, 2);
    Max(1, 2, 4);
    return 0;
}

• 类模板：

为什么要用类模板？
因为多快好省啊！
我们要是不用类模板滴话，遇到很多类比较相似，比如：数据成员相同，成员函数相同的情况下，只是数据成员的类型不同，用类模板就很方便好使。
那我继续来个栗子：
这是一个无类模板的代码：

    class Compare  
    {  
        public:  
            Compare(int a,int b)//构造函数，用于初始化  
            {  
                x = a;  
                y = b;  
            }  
            int max()//求较大值  
            {  
                return (x>y)?x:y;  
            }  
            int min()//求较小值  
            {  
                return (x<y)?x:y;  
            }  
        private:  
            int x;  
            int y;    
    };  

这是有类模板的代码：

    template <class Type>  
    class compare  
    {  
        public:  
            compare(Type a,Type b)  
            {  
                x = a;  
                y = b;  
            }  
            Type max()  
            {  
                return (x>y)?x:y;  
            }  
            Type min()  
            {  
                return (x<y)?x:y;  
            }  
        private:  
            Type x;  
            Type y;  
    };  

main函数代码：

    int main(void)  
    {     
        compare<int> C1(3,5);  
        cout<<"最大值："<<C1.max()<<endl;  
        cout<<"最小值："<<C1.min()<<endl;  
          
        compare<float> C2(3.5,3.6);  
        cout<<"最大值："<<C2.max()<<endl;  
        cout<<"最小值："<<C2.min()<<endl;  
          
        compare<char> C3('a','d');  
        cout<<"最大值："<<C3.max()<<endl;  
        cout<<"最小值："<<C3.min()<<endl;  
        return 0;  
    }  

如何将类转化为类模板

（1）写出一个类

（2）将类型需要改变的地方进行替换（如上面的Type）

（3）在类的前面加入关键字template以及函数参数表

（4）定义对象的格式 类名+<Type>+ xx（参数）

比如上面的compare<int> C1(3,5);

（5）切记，模板函数如果定义在类体外，需要在前面加上一行template <函数参数表>。并在类模板名后面用尖括号加上<虚拟函数参数>

比如

template<class Type>

Type compare <Type>::max()

{

       //.....

}

目前就总结到这啦，要是有什么新想法我还会继续补充的，我先去做几道题，要是有好的题目我就分享给大家嘻嘻嘻，再见~