补充

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;
}
1
2
3
4
5
6
7
8
9
10
11

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

在print_list函数定义中，这个list是虚拟类型，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;
}
1
2
3
4
5
6
7
8
9
10
11

非类型模板参数

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

class T是类型形参，传入数据类型

size_t N是非类型形参，传入常量

举例:

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

使用非类型模板参数

template<class T，size_t N>
class stack
{
private:
    T _a[N];
    int _top;
}
1
2
3
4
5
6
7

补充：

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

模板的特化

概念：

通常情况下，使用模板可以实现一些与类型无关的代码，但对于一些特殊类型的可能会得到一些错误的结果，需要特殊处理。

此时，就需要对模板进行特化。即：在原模板类的基础上，针对特殊类型所进行特殊化的实现方式。模板特化中分为函数模板特化与类模板特化。

函数模板特化

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

特殊化处理

//基础模板
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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

调用原则：

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

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

类模板特化

全特化

//基础模板
template<class T1, class T2>
class Data
{
public:
    Data() {cout<<"Data" <<endl;}
private:
    T1 _d1;
    T2 _d2;
};
//特化模板
template<>
class Data<int, char>
{
public:
    Data() {cout<<"Data" <<endl;}
private:
    int _d1;
    char _d2;
};
void TestVector()
{
    Data<int, int> d1;
    Data<int, char> d2;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

偏特化

//基础模板
template<class T1, class T2>
class Data
{
public:
   Data() {cout<<"Data" <<endl;}
private:
   T1 _d1;
   T2 _d2;
};
1
2
3
4
5
6
7
8
9
10

偏特化有两种表现方式：

1. 对部分模板参数特化

   // 将第二个参数特化为int
   template <class T1>
   class Data<T1, int>
   {
   public:
       Data() 
       {
           cout<<"Data" <<endl;
       }
   private:
       T1 _d1;
       int _d2;
   };
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13

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

   //两个参数偏特化为指针类型
   template <class T1, class T2>
   class Data <T1*, T2*>
   {
   public:
       Data() {cout<<"Data" <<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" <<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); // 调用特化的指针版本
   }
   
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33