做 网站 技术支持 抓获 互助嘉兴seo外包公司

我们在前面已经初识了 模板并且在各种数据结构的实现中，熟练掌握了模板的一些基础功能。
至于为什么是基础功能，因为模板还有一些进阶的功能，像非类型模板参数，缺省参数，模板特化之类的。

非类型模板参数

模板是否一定是要接受类型参数呢？能否接受其他类型参数，答案是可以的。
C++的stl中有一种类array其模板为：template < class T, size_t N > class array;
也就是说我们可以这样使用它：

array<int, 10> a1;

这里我们就使用了一个非类型模板参数，还有没有其他非类型模板参数呢？
出乎意料的，答案是没有。也就是说作为非类型模板参数有且仅有size_t.（C++11）

缺省模板参数

事实上，之前实现queue的时候，我们就用过缺省的模板参数，也就是template<class T, class Container = deque<int>>。

类模板特化

对于一个比较类：

template<class T>
bool Less(T left, T right)
{return left < right;
}

考虑我们前面实现过的日期类，拿他来比较：

int main()
{Date d1(2025, 3, 12);Date d2(2025, 4, 12);cout << Less(d1, d2) << endl;cout << Less(&d1, &d2) << endl;int x = 1, y = 2;cout << Less(x, y) << endl;cout << Less(&x, &y) << endl;return 0;
}

显然，对于d1,d2比较是可以得到正确的结果，但对于&x,&y就很难得到正确的结果。因为后者比较的是地址大小。
当然我们也可以写一个仿函数来解决这个问题，这里提另一种处理方法，就是对其类模板特化：

template<>
bool Less<Date*>(Date* left, Date* right)//bool Less(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;
}

Output:
Data<T1, T2>
Data<int, char>

偏特化

我们当然可以选择对部分参数特化而非全部参数：

template <class T1>
class Data<T1, int>
{
public:
Data() {cout<<"Data<T1, int>" <<endl;}
private:
T1 _d1;
int _d2;
};

除此之外，还能对所有模板参数的类型做一定限制，也属于偏特化：

template <typename T1, typename T2>
class Data <T1*, T2*>
{
public:
Data() {cout<<"Data<T1*, T2*>" <<endl;}
private:
T1 _d1;
T2 _d2;
};

这样我们的模板参数T1和T2如果是指针的话就会优先调用这个特化的模板。

• 但注意我们的T1和T2如果是指针，比如int*。
  那按理说下面这个Data <T1*, T2*>不就应该是Data <int**, int**>
  事实并非如此，而是Data <int*, int*>。
  也就是说T1和T2整体替换成了T1*和 T2*。

模板的分离编译

首先我们要了解一个概念，模板的按需实例化。

仔细想想，模板实际上是编译器帮我们写函数或者类的一种方式，那么传入参数有无穷多种，编译器自然不可能对所有参数都编译一个代码。

也就是说我们写了一个模板函数之后，编译器是不会直接实例化他的，当你调用这个函数的时候才会。

具体案例：

template<class T,size_t N>
class myarray
{T& operator[](size_t index){size(1);//按需实例化。由于没有调用operator[],即没有实例化，故没有检查出语法错误}size_t size()const{return _size;}size_t _size;
};
int main()
{return 0;
}

可以看到我们的operator[]里面有一个明显的语法错误，就是size的参数传多了。但是这时候编译的话，编译器是不会报错的！ 因为operator[]这个函数目前还不存在。
但如果我们在main函数里面调用它的话：

int main()
{myarray a;a[0];
}

这时候编译器就会报错了。

那么接下来我们再看到模板的分离编译。
考虑模板函数的声明定义在不同文件中：

// a.h
namespace myadd
{template<class T>T Add(const T& left, const T& right);
}
// a.cpp
#include"a.h"
template<class T>
T Add(const T& left, const T& right)
{
return left + right;
}

首先这时候由于命名空间的原因，我们的a.cpp实际上实现的不是a.h里面的Add。我们需要给他加上命名空间或者访问限定符：

// a.cpp
namespace myadd
{template<class T>T Add(const T& left, const T& right){return left + right;}
}

这时候看似没有问题了，但如果我们尝试调用他的话：

//main.cpp
#include"a.h"
#include<iostream>
int main()
{int a = 1, b = 10;std::cout << myadd::Add(a, b) << std::endl;return 0;
}

error LNK2019: 无法解析的外部符号 “int __cdecl myadd::Add(int const &,int const &)”
编译器会给我们一个链接错误。
实际上就是上文提及的按需实例化引起的。由于在链接之前，源文件和头文件是不会互通有无的。导致源文件中实现了Add函数的位置，并不知道需要实例化什么类型的函数。这就导致函数无定义。
解决方法有手动实例化：

//a.cpp
#include"a.h"
namespace myadd
{template<class T>T Add(const T& left, const T& right){return left + right;}template int Add(const int& left, const int& right);
}

这里template int Add(const int& left, const int& right);就手动实例化了一个模板参数为int的Add函数。
但这样的方式明显治根不治本。哪有人写了模板函数还得去一个一个手动实例化的？
因此更好的解决方案是：模板函数的定义和声明写在同一个文件里！
不分离就不会有问题了，233.