17. C++类模板

在C++中我们往往需要编写多个形式和功能都相似的类，于是 引人了类模板的概念，编译器从类模板可以自动生成多个类，避免了程序员的重复工作。

17.1 类模板基本格式

C++ 中类模板的写法如下：

template <类型参数表>
class 类模板名{
    成员函数和成员变量
};

类型参数表的写法如下：

class类塑参数1, class类型参数2, ...

类模板中的成员函数放到类模板定义外面写时的语法如下：

template <类型参数表>
返回值类型  类模板名<类型参数名列表>::成员函数名(参数表)
{
    ...
}

用类模板定义对象的写法如下：

类模板名<真实类型参数表> 对象名(构造函数实际参数表);

如果类模板有无参构造函数，那么也可以使用如下写法：

类模板名 <真实类型参数表> 对象名;

类模板看上去很像一个类。下面以 Pair 类模板为例来说明类模板的写法和用法。

实际中，某项数据记录由两部分组成，一部分是关键字，另一部分是值。关键字用来对记录进行排序和检索，根据关键字能查到值。如，学生记录由两部分组成，一部分是学号，另一部分是绩点。要能根据学号对学生进行排序，以便方便地检索绩点，则学号就是关键字，绩点就是值。
例如：

#include <iostream>
#include <string>
using namespace std;
template <class T1,class T2>
class Pair
{
public:
    T1 key;  //关键字
    T2 value;  //值
    Pair(T1 k,T2 v):key(k),value(v) { }
    bool operator < (const Pair<T1,T2> & p) const;
};
template<class T1,class T2>
bool Pair<T1,T2>::operator < (const Pair<T1,T2> & p) const
//Pair的成员函数 operator <
{ //"小"的意思就是关键字小
    return key < p.key;
}
int main()
{
    Pair<string,int> student("哈哈",23); //实例化出一个类 Pair<string,int>
    cout << student.key << " " << student.value;
    return 0;
}

image.png

17.2 函数模板作为类模板成员

类模板中的成员函数还可以是一个函数模板。成员函数模板只有在被调用时才会被实例化。例如下面的程序：

#include <iostream>
using namespace std;
template <class T>
class A
{
public:
    template <class T2>
    void func(T2 t) { cout << t; }  //成员函数模板
};
int main()
{
    A<int> a;
    a.func('K');  //成员函数模板Func被实例化
    a.func("hello");
    return 0;
}

17.3 C++用类模板实现可变长数组

#include <iostream>
#include <cstring>
using namespace std;
template <class T>
class Array
{
    int size; //数组元素的个数
    T *ptr; //指向动态分配的数组
public:
    Array(int s = 0);  //s代表数组元素的个数
    Array(Array & a);
    ~Array();
    void push_back(const T & v); //用于在数组尾部添加一个元素v
    Array & operator=(const Array & a); //用于数组对象间的赋值
    T length() { return size; }
    T & operator[](int i)
    {//用以支持根据下标访问数组元素，如a[i] = 4;和n = a[i]这样的语句
        return ptr[i];
    }
};
template<class T>
Array<T>::Array(int s):size(s)
{
     if(s == 0)
         ptr = NULL;
    else
        ptr = new T[s];
}
template<class T>
Array<T>::Array(Array & a)
{
    if(!a.ptr) {
        ptr = NULL;
        size = 0;
        return;
    }
    ptr = new T[a.size];
    memcpy(ptr, a.ptr, sizeof(T ) * a.size);
    size = a.size;
}
template <class T>
Array<T>::~Array()
{
     if(ptr) delete [] ptr;
}
template <class T>
Array<T> & Array<T>::operator=(const Array & a)
{ //赋值号的作用是使"="左边对象里存放的数组，大小和内容都和右边的对象一样
    if(this == & a) //防止a=a这样的赋值导致出错
    return * this;
    if(a.ptr == NULL) {  //如果a里面的数组是空的
        if( ptr )
            delete [] ptr;
        ptr = NULL;
        size = 0;
        return * this;
    }
     if(size < a.size) { //如果原有空间够大，就不用分配新的空间
         if(ptr)
            delete [] ptr;
        ptr = new T[a.size];
    }
    memcpy(ptr,a.ptr,sizeof(T)*a.size);
    size = a.size;
     return *this;
}
template <class T>
void Array<T>::push_back(const T & v)
{  //在数组尾部添加一个元素
    if(ptr) {
        T *tmpPtr = new T[size+1]; //重新分配空间
    memcpy(tmpPtr,ptr,sizeof(T)*size); //拷贝原数组内容
    delete []ptr;
    ptr = tmpPtr;
}
    else  //数组本来是空的
        ptr = new T[1];
    ptr[size++] = v; //加入新的数组元素
}
int main()
{
    Array<int> a;
    for(int i = 0;i < 5;++i)
        a.push_back(i);
    for(int i = 0; i < a.length(); ++i)
        cout << a[i] << " ";
    return 0;
}

image.png

注意：
1、类模板中可以定义静态成员，从该类模板实例化得到的所有类都包含同样的静态成员。

#include <iostream>
using namespace std;
template <class T>
class A
{
private:
    static int count;
public:
    A() { count ++; }
    ~A() { count -- ; }
    A(A &) { count ++ ; }
    static void PrintCount() { cout << count << endl; }
};

/*
下面也可以这样写
int A<int>::count = 0;
int A<double>::count = 0;

*/

template<> int A<int>::count = 0;
template<> int A<double>::count = 0;


int main()
{
    A<int> ia;
    A<double> da;
    ia.PrintCount();
    da.PrintCount();
    return 0;
}

2、类模板的“类型参数表”中可以出现非类型参数

#include <iostream>
using namespace std;
template<class T, int size>
class Array {
T array[size];
public:
    void Print()
    {
        for (int i = 0; i < size; ++i)
        cout << array[i] << endl;
    }
};

int main()
{

    return 0;
}

可以用 CArray 模板定义对象

Array<int, 40> a;

编译器自动生成名为 CArray<int, 40> 的类。该类是通过将 CArray 模板中的 T 换成 int、 size 换成 40 后得到的。

还可定义以下对象：

Array <double, 40> a2;
Array <int, 50> a3;

注意，Array<double, 40> 和 Array<int, 50> 完全是两个类，这两个类的对象之间不能互相赋值。