C++中的非类型模板参数丶模板特化和分离编译
C++中的非类型模板参数丶模板特化和分离编译
- 一丶非类型模板参数
- 二丶模板的特化
- 2.1 概念
- 2.2 函数模板特化
- 2.3 类模板特化
- I.全特化
- II.偏特化
- 三丶模板的分离编译
- 3.1 什么是分离编译
- 3.2 模板的分离编译
- 3.3 对应的解决方案
- 四丶模板总结
一丶非类型模板参数
模板参数分为类类型形参和非类型形参。
类类型形参：出现在模板参数列表中，跟在class和typename之后的参数类型名称。
非类型形参：即用一个常量作为类(或函数)模板的一个参数，在类(或函数)模板中可将该参数当成常量来使用。
template <class T, size_t N = 1>
class Stack
{
public:Stack() = default;void func(){//错误写法 N不可被修改N++;} private:int _a[N];int _top;
};
模板中的参数可以有缺省值，无论是否为类类型参数。
需要格外注意的是，上面的N是一个常量，也就是说，非类型模板参数，都是一个常量。这意味着不能对它进行修改。
此外，对于非类型模板参数的类型是有一定的限制的。传统的非类型模板参数的类型只能是整型，也支持整型指针。在C++20后，支持double等其他内置类型作为非类型模板参数的类型。但是，自定义类型不能做非类型模板参数。
当模板列表传入的参数不同时，将实例化不同的类型。
int main()
{//不同的模板将生成不同的类型//这里一个模板实例类型是<int, 10>,另一个模板实例类型是<int, 100> 它们是不同的类型Stack<int, 10> st1;Stack<int, 100> st2;//非类型模板参数定义的是一个常量//在调用func是才会按需实例化出func函数//由于常量N不能++ 因此会报错//不调用则不报错 ，因为不调用时func为进行实例化//调用才会去实例化st1.func(); return 0;
}
注意：非类型的模板参数必须在编译时期就能确认结果。
二丶模板的特化
2.1 概念
通常情况下，使用模板可以实现一些与类型无关的代码。但对于一些特殊类型的可能会得到一些错误的结果，需要特殊处理。比如：我们要比较Date类的大小，编写了一个如下的模板。
// 函数模板 -- 参数匹配
template<class T>
bool Less(T left, T right)
{return left < right;
}
int main()
{cout << Less(1, 2) << endl; // 可以比较，结果正确Date d1(2022, 7, 7);Date d2(2022, 7, 8);cout << Less(d1, d2) << endl; // 可以比较，结果正确Date* p1 = &d1;Date* p2 = &d2;cout << Less(p1, p2) << endl; // 可以比较，结果错误return 0;
}
可以看到，当传入指针时，比较的是指针的大小，这不是我们预期的效果。
此时，就需要对模板进行特化。即：在原模版类的基础上，针对特殊类型所进行特殊化实现方式。模板特化中分为函数模板特化和类模板特化。
2.2 函数模板特化
函数模板的特化步骤：
- 1.必须要先有一个基础的函数模板。
- 2.关键字template后面接一对空的尖括号<>。
- 3.函数名后跟一对尖括号，尖括号中指定需要特化的类型。
- 4.函数形参表：必须要和模板参数的基础参数类型完全相同，如果不同，那么编译器可能会报一些奇怪的错误。
针对开头Date类的指针比较问题，我们在这里利用模板特化来处理。
//函数模板特化
template<class T>
bool Less(const T& left, const T& right)
{ //此处的const修饰的是left和rightreturn left < right;
}//特化模板：应对特殊情况 并进行特殊化处理的操作
template<>
bool Less<Date*>(Date* const& left, Date* const& right)
{ //那么此处的const也必须修饰left和right//此处的const不能放到Date*之前 否则const修饰的就是*left和*right//那么就和上面的模板不一致而导致编译不通过cout << "特殊化处理！" << endl;return *left < *right;
}int main()
{Date d1(2022, 7, 7);Date d2(2022, 7, 8);cout << Less(d1, d2) << endl;cout << endl;Date* p1 = &d1;Date* p2 = &d2;//实现特化后 将调用特化版本的cout << Less(p1, p2) << endl;return 0;
}
我们观察发现，函数模板特化，相当于编写了对应的普通函数。一般函数模板特化的使用场景是针对函数模板遇到不能处理或者处理有误的类型时(比方说上面需要传递Date*时)，为了对其进行特殊处理使用的。
这种场景还要求参数的类型比较简单，若参数类型比较复杂，那么使用特化时出错的概率较高。比如：
//函数模板特化
template<class T>
bool Less(const T& left, const T& right)
{ //此处的const修饰的是left和rightreturn left < right;
}//特化模板：应对特殊情况 并进行特殊化处理的操作
template<>
bool Less<Date*>(Date* const& left, Date* const& right)
{ //那么此处的const也必须修饰left和right//此处的const不能放到Date*之前 否则const修饰的就是*left和*right//那么就和上面的模板不一致而导致编译不通过cout << "特殊化处理！" << endl;return *left < *right;
}
如果对代码和语法的理解不够的话，这里const的位置很有可能会放错，而导致出现一些奇奇怪怪的编译报错。
因此，一般对于较复杂的类型时，不建议使用函数模板特化。
2.3 类模板特化
I.全特化
全特化即是将模板参数列表中所有的参数都确定化。
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; //全特化
}
II.偏特化
偏特化：任何针对模板参数进一步进行条件限制设计的特化版本。
偏特化的表现方式有两种：
- 1.部分特化：将模板参数类表中的一部分参数特化。
// 将第二个参数特化为int
template <class T1>
class Data<T1, int>
{
public:Data() { cout << "Data<T1, int>" << endl; }
private:T1 _d1;int _d2;
};
- 2.参数更进一步的限制：偏特化并不仅仅指特化部分参数，而是针对模板参数更进一步的条件限制所设计出来的一个特化版本。
//两个参数偏特化为指针类型
template <typename T1, typename 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); // 调用特化的引用版本
}
这里来说明一下关于偏特化各个位置的模板参数的指代。如Data<int*, int*>，那么在模板template <typename T1, typename T2>处的T1和T2是和它对应的，此处的T1和T2对应的是指针。当进入到类内时，根据class Data <T1*, T2*>，此时T1和T2就成了传递的参数去掉了*号的那个，也就说说在这里此时的T1和T2成了int，我们可以拿代码来测试一下：
template<class T1, class T2>
class Data
{
public:Data() { cout << "Data<T1, T2>" << endl; }
private:T1 _d1;T2 _d2;};template <typename T1, typename T2>
//与这里的T1和T2 可以认为不是同一个概念 但是是有联系的
//*符合在这里相当于是一个表示符 告诉我们传入的必须是指针
class Data<T1*, T2*>
{
public://不要以为template <typename T1, typename T2>处的T1和T1是去掉*之后的类型//在实例化<>中传入的是什么 那么T1和T2对应的就是什么//比如：Data<int*, double*> d4;//那么template <typename T1, typename T2>中的// T1就是int*, T2就是double* 而不是int和double//这一点要格外注意//而class Data<T1*, T2*>的T1和T2是去掉*后的对应类型Data() { //这里计算的是class Data<T1*, T2*>处的T1和T2//而不是template <typename T1, typename T2>处的cout << sizeof(T1) << endl;cout << sizeof(T2) << endl;cout << typeid(T1).name() << endl;cout << typeid(T2).name() << endl;cout << "Data<T1*, T2*>-偏特化" << endl << endl;}
};//也是偏特化 或者引用和指针混合使用
template<typename T1, typename T2>
class Data<T1&, T2&>
{
public:Data() {cout << typeid(T1).name() << endl;cout << typeid(T2).name() << endl;cout << "Data<T1&, T2&>-偏特化" << endl;}
};int main()
{Data<int*, double*> d4; //偏特化Data<int*, int**> d5; //偏特化Data<int&, int&> d6; //偏特化return 0;
}类模板特化针对类在使用模板遇到的一些特殊类型的可能会得到一些错误的结果，需要特殊处理的情景。那就比如我们要进行Date类的比较，这时我们只写通用模板，当传入Date*时，很明显达不到我们的预期，这时就需要利用类模板特化了，这就跟上面函数模板特化的使用场景是一致的。
三丶模板的分离编译
3.1 什么是分离编译
分离编译：一个程序(项目)由若干个源文件共同实现，而每一个源文件单独编译生成目标文件，最后将所有文件链接起来形参的可执行文件的这个整体的过程，称之为分离编译模式。
3.2 模板的分离编译
假设有以下场景，模板的声明与定义分离开，在头文件中进行声明，源文件中完成定义：
// a.h
template<class T>
T Add(const T& left, const T& right);// a.cpp
template<class T>
T Add(const T& left, const T& right)
{return left + right;
}
// main.cpp
#include"a.h"
int main()
{Add(1, 2);Add(1.0, 2.0);return 0;
}首先，这样去编译，会报链接错误。这是为什么呢？
我们知道，C/C++程序要运行，一般要进行如下步骤：
预处理 --> 编译 --> 汇编 --> 链接
预处理：该阶段进行宏替换丶头文件展开等操作。
编译：对程序按照语言特性进行词法丶语法丶语义分析（包含着检查声明的操作），错误检查无语后生成汇编代码。
汇编：将编译后的汇编代码文件.asm进行汇编，生成.obj文件。
链接：将多个.obj文件合并成一个，在链接之前各个文件源文件是不进行交互的，在链接阶段通过函数名来找到其函数地址。
【注意】：头文件是不参与编译的，编译器对工程中的多个源文件是分离开单独编译的。
好的，有了上面的知识基础，我们来捋一捋函数模板分离编译报出链接错误的原因：
普通函数，在声明和定义分离(该分离指的是声明和定义存在于不同的文件)时，进行编译和链接是没有问题的。它首先进行预处理，然后编译，头文件.h不参与编译过程，那么.cpp文件进行编译，在编译阶段，普通函数的定义将生成对应的函数地址，放入符号表中。然后再汇编，各个.cpp文件生成对应的.obj目标文件。此时到里链接阶段，链接阶段会通过函数名来找到函数地址，该地址在编译阶段生成了，所以可以找得到，那么链接就不会出现错误的。
但是，对于函数模板，我们知道，编译器不会编译函数模板，那么在编译过程中，函数模板的定义因为没有实例化（或者说是不知道该如何实例化，因为此时未到链接阶段，各个源文件不会进行交互），不会生成对应的函数地址，那么在链接阶段，模板函数调用处就无法找到其函数模板定义的地址，那么就会出现链接错误。
3.3 对应的解决方案
有两种解决方案：
- 1.将声明和定义放到一个文件"xxx.hpp"或者"xxx.h"其实也是可以的。
//a.h
template<class T>
T Add(const T& left, const T& right);template <class T>
T Add(const T& left, const T& right)
{cout << "T Add(const T& left, const T& right)" << endl;return left + right;
}这种方案解决问题的原因是：将声明和定义放到同一个.h文件文件时，一般其他需要使用该.h文件的.cpp文件会包含该.h文件，那么在预处理阶段.h文件会在.cpp文件中进行头文件展开，展开后，在.cpp文件中既有函数模板的声明和定义，又有函数模板的调用处(该调用处会指明实例化，此时将帮助函数模板生成其地址)。
- 2.在模板定义的位置显式实例化。
//a.h
template<class T>
T Add(const T& left, const T& right);//a.cpp
template <class T>
T Add(const T& left, const T& right)
{cout << "T Add(const T& left, const T& right)" << endl;return left + right;
}//显式实例化
template
int Add(const int& left, const int& right);template
double Add(const double& left, const double& right);//main.cpp
int main()
{Add(1, 2); //显式实例化为intAdd(1.0, 2.0); //显式实例化为doublereturn 0;
}第一种方式推荐使用，直接将声明和定义放到一个文件中；第二种方式不实用，因为每一次传递不同的参数，都得显式实例化，太麻烦了，不推荐。
四丶模板总结
【优点】
- 1.模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库STL因此而产生。
- 2.增强了代码的灵活性。
【缺陷】
- 1.模板会导致代码膨胀问题，也会导致编译时间变长。
- 2.出现模板编译错误时，错误信息非常凌乱，不易定位错误。
本博客仅供个人参考，如有错误请多多包含。
Aruinsches-C++日志 -- 7 / 12 / 2024