C++模板进阶使用技巧
- 非类型模板参数
- 缺省模板参数
- 类模板特化
-
- 全特化
- 偏特化
- 模板的分离编译
我们在前面已经初识了 模板并且在各种数据结构的实现中，熟练掌握了模板的一些基础功能。
至于为什么是基础功能，因为模板还有一些进阶的功能，像非类型模板参数，缺省参数，模板特化之类的。
非类型模板参数
模板是否一定是要接受类型参数呢？能否接受其他类型参数，答案是可以的。
C++的stl中有一种类array其模板为：template < class T, size_t N > class array;
也就是说我们可以这样使用它：
array<int, 10> a1;
这里我们就使用了一个非类型模板参数，还有没有其他非类型模板参数呢？
出乎意料的，答案是没有。也就是说作为非类型模板参数有且仅有size_t.（C++11）
缺省模板参数
事实上，之前实现queue的时候，我们就用过缺省的模板参数，也就是template
类模板特化
对于一个比较类：
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" <<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;
}
Output:
Data
Data
偏特化
我们当然可以选择对部分参数特化而非全部参数：
template <class T1>
class Data<T1, int>
{
public:
Data() {cout<<"Data" <<endl;}
private:
T1 _d1;
int _d2;
};
除此之外，还能对所有模板参数的类型做一定限制，也属于偏特化：
template <typename T1, typename T2>
class Data <T1*, T2*>
{
public:
Data() {cout<<"Data" <<endl;}
private:
T1 _d1;
T2 _d2;
};
这样我们的模板参数T1和T2如果是指针的话就会优先调用这个特化的模板。
- 但注意我们的T1和T2如果是指针，比如int*。
那按理说下面这个Data
事实并非如此，而是Data
也就是说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"
#includeerror 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.