类模板

类模板

---

类模板

类模板是用于生成类的模板 在编译阶段，编译器会根据类模板的使用情况创建出：
仅部分成员数据类型，和部分成员函数的参数类型不同，其他完全形同的若干类。
通过类模板的这些特性我们可以尝试写出 用于存放不同类型数据的容器。

类模板声明、定义

#include <iostream>
#include <string>
using namespace std;

template <typename T>//类模板可以放在头文件中声明
class MyArray
{
private:
    T data[20];
    int len;
public:
    MyArray();
    T indexof(int index);
    //在类体里定义模板函数
    //类模板声明放在头文件里
    void addValue(T value)
    {
        data[len] = value;
        len++;
    }
};
template <typename T>//类模板的成员函数定义
MyArray<T>::MyArray()
    :len(0)
{

}
template <typename T>//不可省略，否则编译报错
T MyArray<T>::indexof(int index)
{
    return data[index];
}
int main(void)
{
    MyArray<int> arr;
    int i = 0;
    for(i = 0;i < 10;++i)
    {
        arr.addValue(i);
    }
    for(i = 0;i < 10;++i)
    {
        cout << arr.indexof(i) << endl;
    }

    return 0;
}

---

类模板的特化

类模板特化是指在实例化类模板时，对特定类型的泛型进行特殊的处理
用户指定所有特定类型的类模板时，通过特化过类模板生成的类可能与其他类有完全不同的结构 特化类模板是需要对整个类模板进行声明定义

#include <iostream>
#include <string>
using namespace std;

template <typename T>//类模板可以放在头文件中声明
class MyArray
{
private:
    T data[20];
    int len;
public:
    MyArray();
    T indexof(int index);
    //也在类体里定义模板函数
    //类模板声明放在头文件里
    void addValue(T value)
    {
        data[len] = value;
        len++;
    }
};
template <typename T>//类模板的成员函数定义
MyArray<T>::MyArray()
    :len(0)
{

}

template <typename T>//不可省略，否则编译报错
T MyArray<T>::indexof(int index)
{
    return data[index];
}

template <>//特化类声明
class MyArray<double>//把模板类特化为只为double服务
{
    public:
        MyArray();
};
MyArray<double>::MyArray()//不需要特化类的声明
{
    cout << "MyArray<double>::MyArray()" << endl;
}
int main(void)
{
    MyArray<double> arr;

    return 0;
}

---

类模板的偏特化

偏特化与特化类似，只是特化会指定所有的泛型 而偏特化只指定部分泛型 偏特化类模板需要对整个类模板进行声明定义

#include <iostream>
#include <string>
using namespace std;

template <typename T1,typename T2>
class Pair
{
private:
    T1 first;
    T2 second;
public:
    Pair();
};
template <typename T1,typename T2>
Pair<T1,T2>::Pair()
{
    cout << "Pair<T1,T2>::Pare()" << endl;
}
//下面偏特化类
//偏特化T1
template<typename T2>//偏特化类声明//T2不需特化的泛型
class Pair<char,T2>//为char开小灶，T2不需特化的泛型
{
public:
    Pair();
};

template<typename T2>//偏特化不能省略偏特化类的声明
Pair<char,T2>::Pair()
{
    cout << "Pair<char,T2>::Pair()" << endl;
}

int main(void)
{
    Pair<int,char> pair1;
    Pair<char,int> pair2;
}

#include <iostream>
#include <string>
using namespace std;

template <class T1,class T2>
class Point
{
private:
    T1 x;
    T2 y;
protected:
public:
    Point();
    Point(T1 x,T2 y)
        :x(x),y(y)
    {

    }
    T1 getX(void);
    T2 getY(void);
};

template <typename T1,typename T2>
T1 Point<T1,T2>::getX(void)
{
    return x;
}   
template <typename T1,typename T2>
T2 Point<T1,T2>::getY(void)
{
    return y;
}


int main(void)
{
    Point<int,int> point1(1,1);
    cout << point1.getX() <<"," << point1.getY()<< endl;
    Point<int,double> point2(2,2.3);
    cout << point2.getX() <<"," << point2.getY()<< endl;
    return 0;
}