当前位置：网站首页>模板的进阶

模板的进阶

2022-08-02 19:41:00 【百言灵都】

补充

template<class T>
void print_list(const list<T>& it)
{
    
    list<T>::const_iterator cit = It.begin();
    while(cit != It.end())
    {
    
        cout<<*cit<<" ";
        ++cit;
    }
    cout << endl;
}

上述代码会出现错误，如何解决？

在print_list函数定义中，这个list<T>是虚拟类型，list没有实例化，无法去list中寻找const_iterator，这时就需要加上typename，告诉编译器这是一个类型，等list实例化了之后再去寻找，创建对象

template<class T>
void print_list(const list<T>& it)
{
    
    typename list<T>::const_iterator cit = It.begin();
    while(cit != It.end())
    {
    
        cout<<*cit<<" ";
        ++cit;
    }
    cout << endl;
}

非类型模板参数

模板参数分类类型形参与非类型形参。
类型形参即：出现在模板参数列表中，跟在class或者typename之类的参数类型名称。
非类型形参，就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量

class T是类型形参，传入数据类型
size_t N是非类型形参，传入常量

举例:

#define N 100
//静态栈
template<class T>
class stack
{
    
private:
    T _a[N];
    int _top;
}
//不够灵活，解决以上问题使用非类型模板参数

使用非类型模板参数

template<class T，size_t N>
class stack
{
    
private:
    T _a[N];
    int _top;
}

补充：

array相对于原生数组唯一的区别是对于越界的检查
array是一定能够检查出来，
但是原生数组对于越界是抽查，有可能检查不出来

模板的特化

概念：

通常情况下，使用模板可以实现一些与类型无关的代码，但对于一些特殊类型的可能会得到一些错误的结果，需要特殊处理。
此时，就需要对模板进行特化。即：在原模板类的基础上，针对特殊类型所进行特殊化的实现方式。模板特化中分为函数模板特化与类模板特化。

函数模板特化

需要先有一个基础函数模板
关键字template后面接一对空的尖括号<>
函数名后跟一对尖括号，尖括号中指定需要特化的类型
函数形参表: 必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误

特殊化处理

//基础模板
template<class T>
bool Less(T left, T right)
{
     
return left < right;
}
//特化模板
template<>
bool Less<Date*>(Date* left,Date* right)
{
     
    return *left < *right;
}
//函数
bool Less(Date* left,Date* right)
{
     
    return *left < *right;
}

调用原则：
先使用已经存在的函数，如果不匹配再使用特化模板，不匹配，使用基础模板

函数模板一般不使用特化，直接写一个具体函数

类模板特化

全特化

//基础模板
template<class T1, class T2>
class Data
{
     
public:
    Data() {
     cout<<"Data<T1, T2>" <<endl;}
private:
    T1 _d1;
    T2 _d2;
};
//特化模板
template<>
class Data<int, char>
{
     
public:
    Data() {
     cout<<"Data<int, char>" <<endl;}
private:
    int _d1;
    char _d2;
};
void TestVector()
{
     
    Data<int, int> d1;
    Data<int, char> d2;
}

偏特化

//基础模板
template<class T1, class T2>
class Data
{
     
public:
   Data() {
     cout<<"Data<T1, T2>" <<endl;}
private:
   T1 _d1;
   T2 _d2;
};

偏特化有两种表现方式：

对部分模板参数特化

// 将第二个参数特化为int
template <class T1>
class Data<T1, int>
{
       
public:
    Data() 
    {
       
        cout<<"Data<T1, int>" <<endl;
    }
private:
    T1 _d1;
    int _d2;
};

对模板参数进行进一步限制

//两个参数偏特化为指针类型
template <class T1, class T2>
class Data <T1*, T2*>
{
       
public:
    Data() {
       cout<<"Data<T1*, T2*>" <<endl;}
private:
    T1 _d1;
    T2 _d2;
};
//两个参数偏特化为引用类型
template <typename T1, typename T2>
class Data <T1&, T2&>
{
       
public:
    Data(const T1& d1, const T2& d2)
        : _d1(d1)
		, _d2(d2)
        {
       
            cout<<"Data<T1&, T2&>" <<endl;
        }
private:
    const T1 & _d1;
    const T2 & _d2;
};
void test2 ()
{
       
    Data<double , int> d1; // 调用特化的int版本
    Data<int , double> d2; // 调用基础的模板
    Data<int *, int*> d3; // 调用特化的指针版本
    Data<int&, int&> d4(1, 2); // 调用特化的指针版本
}