C++——模板小结

模板

模板（Template）指C++程序设计设计语言中采用类型作为参数的程序设计，支持通用程序设计。C++ 的标准库提供许多有用的函数大多结合了模板的观念，如STL以及IO Stream。模板是C++支持参数化多态的工具，使用模板可以使用户为类或者函数声明一种一般模式，使得类中的某些数据成员或者成员函数的参数、返回值取得任意类型。

模板是一种对类型进行参数化的工具；

通常有两种形式：函数模板和类模板；

（一）函数模板

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

　　　{

　　　　　　函数体

　　　}

下面我们以一个交换变量的程序来展示函数模板的作用

#include<iostream>
using namespace std;
void Swap(int &a,int &b)
{
    int t = a;
    a = b;
    b = t;
}
int main(int argc, char const *argv[])
{
    int a = 23,b = 45;
    char c = 'a',d = 'b';
    Swap(a,b);
    //Swap(c,d); //报错,因为我们只能交换int类型的两个变量
    cout<<a<<" "<<b<<endl;
    return 0;
}

这是我们普通的交换变量的程序，但它有局限，我们只能交换一种我们规定好的类型变量，换一种就不能交换了，当然我们也可以用重载的办法，但重载就意味着我们要写出包括所有情况的函数，这样工作量很大，有没有简单一点的办法呢？这时候我们就要用到模板了，用一个函数来实现所有的。

#include<iostream>
using namespace std;
void Swap(int &a,int &b)
{
    int t = a;
    a = b;
    b = t;
}
template<class T>
void Swap(T &a,T &b)
{
    T temp = a;
    a = b;
    b = temp;
}
int main(int argc, char const *argv[])
{
    int a = 23,b = 45;
    char c = 'a',d = 'b';
    Swap(a,b);
    cout<<a<<" "<<b<<endl;
    Swap(c,d);
    cout<<c<<" "<<d<<endl;
    return 0;
}

看结果，我们可以看到，不仅是int型的，char型的也可以交换，当然我们还可以交换double型的，但大家注意，因为我们前面有写普通的交换函数，所有会默认调用普通的函数，原因是虽然编译器会帮我们做类型转换（T变成int），但能不转的时候编译器不会转，大家可以试试，那如果我们要指定用我们写的模板函数怎么办呢？

Swap<>(int a,int b)//这样就会指定调用模板函数

#include<iostream>
using namespace std;
void Swap(int &a,int &b)
{
    cout<<"普通函数"<<endl;
    int t = a;
    a = b;
    b = t;
}
template<class T>
void Swap(T &a,T &b)
{
    cout<<"模板函数"<<endl;
    T temp = a;
    a = b;
    b = temp;
}
int main(int argc, char const *argv[])
{
    int a = 23,b = 45;
    char c = 'a',d = 'b';
    Swap(a,b);
    cout<<a<<" "<<b<<endl;
    Swap(c,d);
    cout<<c<<" "<<d<<endl;
    return 0;
}

看上面的运行结果我们可以发现，编译器调用的是普通函数，当我们指定要调用模板函数时

#include<iostream>
using namespace std;
void Swap(int &a,int &b)
{
    cout<<"普通函数"<<endl;
    int t = a;
    a = b;
    b = t;
}
template<class T>
void Swap(T &a,T &b)
{
    cout<<"模板函数"<<endl;
    T temp = a;
    a = b;
    b = temp;
}
int main(int argc, char const *argv[])
{
    int a = 23,b = 45;
    char c = 'a',d = 'b';
    Swap<>(a,b);
    cout<<a<<" "<<b<<endl;
    Swap(c,d);
    cout<<c<<" "<<d<<endl;
    return 0;
}

我们可以看到，在Swap后面加<>之后就会指定调用模板函数。或者Swap<int>(a,b)，这样编译器就不用去进行类型推导了。

（二）类模板

模板类格式如下：

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

类模板的话，我们以一个实例来引出：

需求：
写一个各边长度的数组类Array
用于存放各种元素，个数未知
设计：
内部动态申请一个buffer
capacity：表示buffer的大小
size：表示buffer已经存放元素的个数
接口：
Size():
Capacity():最大容量
Clear():清空，使size为0，capacity不变
PushBack():添加一个元素。

问题：这个问题我们首先以double型的为例，代码如下：

#include<iostream>
using namespace std;
#include<string.h>
class Myarry
{
public:
    Myarry(int capacity = 5)    //初始的数组内存
    {
        m_buffer = new double[capacity];  //开辟一个大小为5的内存空间
        m_size = 0;                      //初始size为0
        m_capacity = capacity;           //初始的大小为5
    }
    int Size()                    //已存元素的个数
    {
        return m_size;
    }
    int Capacity()               //开辟的内存大小
    {
        return m_capacity;
    }
    void Clear()                  //清空数组
    {
        delete []m_buffer;        //删除数组
        m_size = 0;               //元素个数清0
        cout<<"Arrary cleared!"<<endl;
    }
    void PushBack(double val)     //添加元素
    {
        if(m_size >= m_capacity)  //如果数组已存的元素个数大于开辟的空间,就开辟内存
        {
            cout<<"Expand the Memory!"<<endl;
            m_capacity = m_capacity + 2;   //扩大两个元素的大小
            double *buffer = new double[m_capacity];  //开辟一个新的空间
            memcpy(buffer,m_buffer,m_capacity * sizeof(double));  //把旧的数组的元素拷贝一下
            delete []m_buffer;   //删除旧的数组
            m_buffer = buffer;    //让数组指针指向新数组
        }
        m_buffer[m_size++] = val;   //把val的值添加到数组中,数组已存长度+1
    }
private:
    double *m_buffer;             //数组指针
    int m_capacity;              //数组内存大小
    int m_size;                  //数组已存元素个数
};
int main(int argc, char const *argv[])
{
    Myarry a;                   //实例化出一个对象
    cout<<"Capacity:"<<a.Capacity()<<endl;  //输出初始数组的大小和已存元素个数
    cout<<"Size:"<<a.Size()<<endl;
    a.PushBack(2.3);     //添加五个元素
    a.PushBack(1.1);
    a.PushBack(3.4);
    a.PushBack(2.1);
    a.PushBack(3.7);
    cout<<"Capacity:"<<a.Capacity()<<endl;  //输出现在数组的大小和已存元素个数
    cout<<"Size:"<<a.Size()<<endl;
    a.PushBack(4.5);              //再添加一个元素,此时已经大于数组的内存大小,需要扩增内存
    cout<<"Capacity:"<<a.Capacity()<<endl;  //输出现在数组的大小和已存元素个数
    cout<<"Size:"<<a.Size()<<endl;
    a.Clear();    //清空数组
    cout<<"Capacity:"<<a.Capacity()<<endl;  //输出现在数组的大小和已存元素个数
    cout<<"Size:"<<a.Size()<<endl;
    return 0;
}

 上面是我们用普通的类实现，但需求是要实现各种类型的，那我们怎么解决呢？这时候就要用到模板类了。

#include<iostream>
using namespace std;
#include<string.h>
template <class T>
class Myarry
{
public:
    Myarry(int capacity = 5)    //初始的数组内存
    {
        m_buffer = new T[capacity];  //开辟一个大小为5的内存空间
        m_size = 0;                      //初始size为0
        m_capacity = capacity;           //初始的大小为5
    }
    int Size()                    //已存元素的个数
    {
        return m_size;
    }
    int Capacity()               //开辟的内存大小
    {
        return m_capacity;
    }
    void Clear()                  //清空数组
    {
        delete []m_buffer;        //删除数组
        m_size = 0;               //元素个数清0
        cout<<"Arrary cleared!"<<endl;
    }
    void PushBack(T val)     //添加元素
    {
        if(m_size >= m_capacity)  //如果数组已存的元素个数大于开辟的空间,就开辟内存
        {
            cout<<"Expand the Memory!"<<endl;
            m_capacity = m_capacity + 2;   //扩大两个元素的大小
            T *buffer = new T[m_capacity];  //开辟一个新的空间
            memcpy(buffer,m_buffer,m_capacity * sizeof(T));  //把旧的数组的元素拷贝一下
            delete []m_buffer;   //删除旧的数组
            m_buffer = buffer;    //让数组指针指向新数组
        }
        m_buffer[m_size++] = val;   //把val的值添加到数组中,数组已存长度+1
    }
    void printf()                  //输出数组中的元素
    {
        T  *ptr = m_buffer;       //定义一个T类型的指针和下面的变量n,用来遍历数组
        int n = m_size;           
        for(int i = 0; i < n;i++)
        {
            cout<<ptr[i]<<" ";
        }
        cout<<endl;
    }
private:
    T *m_buffer;             //数组指针
    int m_capacity;              //数组内存大小
    int m_size;                  //数组已存元素个数
};
int main(int argc, char const *argv[])
{
    Myarry<char> b;
    b.PushBack('a');     //添加五个元素
    b.PushBack('b');
    b.PushBack('z');
    b.PushBack('j');
    b.PushBack('f');
    cout<<"Capacity:"<<b.Capacity()<<endl;
    cout<<"Size:"<<b.Size()<<endl;
    b.PushBack('z');
    b.printf();
    b.Clear();
    cout<<"Capacity:"<<b.Capacity()<<endl;
    cout<<"Size:"<<b.Size()<<endl;
    return 0;
}