C++基础之模板使用

        本次介绍C++模板，仅供参考使用。

一、模板起因

                首先，我们来看一段代码：

void Swap(int& left, int& right)
{
    int temp = left;
    left = right;
    right = temp;
}

void Swap(double& left, double& right)
{
    double temp = left;
    left = right;
    right = temp;
}

void Swap(char& left, char& right)
{
    char temp = left;
    left = right;
    right = temp;
}

        可以看到，虽然C++支持了函数重载，使得一个函数名可以多次利用，可是内容却不能多次利用，那么我们是不是可以再创造一个工具使得代码也可以重复使用呢？再看一图：

        

        可以看到，上图的“模板”是不是很生动形象的解决了复用性的问题？于是祖师爷果断地在C++中加入模板工具，令代码不再因类型的问题而出现多次重复。这一决定，令人不禁拍案叫绝！因为这使得代码从此脱离了类型的束缚，达到了泛型编程的领域。 

二、函数模板

        1.概念

        函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。

        2.格式

        typename是用来定义模板参数关键字，也可以使用class(切记：不能使用struct代替class)

        template<typename T1, typename T2,......,typename Tn>
        返回值类型 函数名(参数列表){}

        不过这样的格式有些抽象，请看下面例子：

template<typename T>
void Swap( T& left, T& right)
{
    T temp = left;
    left = right;
    right = temp;
}

         3.实例化

        看了上面的函数模板，千万不要以为函数模板就是函数了。在模板实例化后才是我们使用的函数，而这种实例化又分为隐式实例化和显示实例化：

        隐式实例化：让编译器根据实参推演模板参数的实际类型

template<class T>
T Add(const T& left, const T& right)
{
    return left + right;
}
int main()
{
    int a1 = 10, a2 = 20;
    double d1 = 10.0, d2 = 20.0;
    Add(a1, a2);
    Add(d1, d2);

    //--->Add(a1, d1);<---注意此点
    /*
    该语句不能通过编译，因为在编译期间，当编译器看到该实例化时，需要推演其实参类型
    通过实参a1将T推演为int，通过实参d1将T推演为double类型，但模板参数列表中只有一个T，
    编译器无法确定此处到底该将T确定为int 或者 double类型而报错
    注意：在模板中，编译器一般不会进行类型转换操作，因为一旦转化出问题，编译器就需要背黑锅
    */

    // 此时有两种处理方式：1. 用户自己来强制转化 2. 使用显式实例化
    Add(a, (int)d);

    return 0;
}

        显式实例化：在函数名后的<>中指定模板参数的实际类型

int main(void)
{
    int a = 10;
    double b = 20.0;
    // 显式实例化
    Add<int>(a, b);
    return 0;
}

        

 *注意：一个非模板函数可以和一个同名的函数模板同时存在，该函数模板还可以被实例化为这个非模板函数，并且使用时参数类型匹配，会优先调用非模板函数。

三、类模板

        1.概念

        类模板代表了一个类的家族，该类模板与类型无关，在使用时被参数化，根据实参类型产生类的特定类型版本。

        2.格式

template<class T1, class T2, ..., class Tn>
class 类模板名
{
    // 类内成员定义
}；

        不过还是来看例子，理解深刻一些：

// 动态顺序表
// 注意：Vector不是具体的类，是编译器根据被实例化的类型生成具体类的模具
template<class T>
class Vector
{
public:
    Vector(size_t capacity = 10)
        : _pData(new T[capacity])
        , _size(0)
        , _capacity(capacity)
    {}
    void PushBack(const T& data);

    //使用模板参数在类中定义函数
    T& operator[](size_t pos)
    {
        assert(pos < _size);  
        return _pData[pos];
    }



    // 使用析构函数演示：在类中声明，在类外定义。
    ~Vector();
private:
    T* _pData;
    size_t _size;
    size_t _capacity;
};


// 注意：类模板中函数放在类外进行定义时，需要加模板参数列表
template <class T>
Vector<T>::~Vector()
{
    if (_pData)
        delete[] _pData;
    _size = _capacity = 0;
}

        3.实例化

        类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类。

// Vector类名，Vector<int>才是类型
Vector<int> s1;
Vector<double> s2;