模版的特性及其编译分离

1.模版的分类

模版参数分为 类型形参 和 非类型形参

类型形参：出现在模版参数列表中，跟在class和typename之后的参数类型名称

非类型形参：就是用一个常量作为类（函数）模版的一个参数，在类（函数）模版中可将该参数当成常量来使用。

非类型参数通常用于定义静态数组或其他容器的大小。

namespace wxw
{template<class T, size_t N = 10>class array{private:T _arr[N];size_t _size;};
}

• 上述情况可以和宏定义对比，但是宏定义是写死的而非类型参数可以是任意大小。
• 指定整形，浮点数，类对象以及字符串是不允许作为非类型模版参数的（但在C++20以后才支持的）
• 非类型的模版参数必须在编译期就能确定结果
• 如果模版中只非类型参数且有缺省值，我们要调用时需要加<>（C++20后不需要）
• 同时非类型参数可以有多个，bool也是属于整形家族。

template<size_t n = 10>class Stack{private:int _a[n];};int main()
{wxw::Stack<> a2;wxw::Stack a3;//C++20以前不支持
}

1.1array和静态数组

库里的array就是用到了非类型模版参数，array和静态数组相比有什么优势呢？

array在越界检查方面更为严格，同时array开空间效率更高。

静态数组越界写的时候采用的抽查，抽查数组后面的两个标记位，如果这两个标记位上被写了，就会检测到，越界读却不会检测。

array不管读或写都要调用operator[]函数array在operator中强制断言检查。

2.模版的特化

2.1 特化的概念

通常情况下，使用模版可以实现一些与类型无关的代码，但对于一些特殊类型的可能会得到一些错误的结果，需要特殊处理，比如：实现了一个专门用来进行小于比较的函数模版

template<class T>
bool Less(T left, T right)
{return left < right;
}int main()
{cout << Less(1, 2) << endl;Date d1(2025, 4, 5);Date d2(2025, 4, 4);cout << Less(d1, d2) << endl;//可以比较，结果正确Date* p1 = &d1;Date* p2 = &d2;cout << Less(p1, p2) << endl;//可以比较，结果错误return 0;
}

可以看到，Less绝大多数情况下都可以正常比较，但是在特殊场景下就得到错误的结果，上述示例中，p1指向的d1显然大于p2指向的d2对象，但是Less内部并没有比较p1和p2指向的对象内容，而比较的是p1和p2指针的地址，这就无法达到预期而错误。

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

2.2函数模版特化

函数模版的特化步骤：

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;
}int main()
{cout << Less(1, 2) << endl;Date d1(2025, 4, 5);Date d2(2025, 4, 4);cout << Less(d1, d2) << endl;//可以比较，结果正确Date* p1 = &d1;Date* p2 = &d2;cout << Less(p1, p2) << endl;//可以比较，结果错误return 0;
}

注意：一般情况下如果函数模版遇到不能处理，或者处理有误的类型，为了实现简单，通常都是将该函数直接给出。

bool Less(Date* left, Date* right)
{return *left < *right;
}

这种实现简单明了，代码可读性高，容易书写，编译器在模版和现有的函数中会优先选择现有的函数。

2.3const

template<class T>
bool Less(const T& left, const T& right)
{return left < right;
}//对Less函数模版进行特化
template<>
bool Less<Date*>(const Date*& left, const Date*& right)
{return *left < *right;
}

特化的参数列表明明和原来的模版一模一样为什么还会报错了？

所以当T是指针类型时，特化版本const要放在指针的右边。

template<>
bool Less<Date*>(Date* const& left, Date* const& right)
{return* left < *right;
}

同时如果const指针我们的特化模版也匹配不上，所有我们也要自己写一个const Date* 的特化

template<>
bool Less<const Date*>(const Date* const& left, const Date* const& right)
{return *left < *right;
}

我们不推荐函数模版的特化，更推荐直接写函数处理。

2.4 类模板特化

2.4.1 全特化

全特化即是将模版参数列表中所以得参数都确定化。

template<class T1,class T2>
class Date
{
public:Date(){cout << "Date<T1, T2>" << endl;}
private:T1 _d1;T2 _d2;
};template<>
class Date<int, char>
{
public:Date(){cout << "Date<int, char>" << endl;}
private:int _d1;char _d2;
};int main()
{Date<int, int> d1;Date<int, char> d2;
}

2.4.2 偏特化

偏特化：任何针对模版参数进一步进行条件限制设计的特化版本。

比如对于以下模版类：

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

偏特化有以下两种表现方式

• 部分特化

        将模版参数列表中的一部分参数特化

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

• 参数更进一步的限制

        偏特化并不仅仅是指特化部分参数，而是针对模版参数更进一步的条件限制所设计出来的一个特化版本。

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

这里的两个偏特化就是针对指针类型和引用类型的特化，也就是说只要是指针或引用就会匹配这两个特化版本。

需要注意的是指针或引用的特化是按照特化版本的参数匹配而非原模版。

这样是为了更方便我们在类模版里面使用类型。

template<class T1, class T2>
class Date<T1*, T2&>
{
public:Date(){cout << "Date<T1*, T2&>" << endl;int c = 0;T1 a = &c;T2 b = c;}
private:T1 _d1;T2 _d2;
};

这段函数编译报错，因为这里的T1不是int*，T2也不是int&

应该改成

template<class T1, class T2>
class Date<T1*, T2&>
{
public:Date(){cout << "Date<T1*, T2&>" << endl;int c = 0;T1* a = &c;T2& b = c;}
private:T1 _d1;T2 _d2;
};

这里int*和int&不是匹配原模版的模版参数，而是匹配特化版本的模版参数，这样设计我们就可以灵活使用，否则我们在类模版里面都无法使用int类型，这样设计我们用指针就T1*，用引用就是T2&即可。

3.模版分离编译

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
int main()
{Add(1, 2);Add(1.0, 2.0);return 0;
}

---

---

• 显示实例化

//显示实例化int类型
template//不加<>和函数特化区分
int Add(const int& left, const int& right);

我们还是更推荐将声明和定义都放在.h中。

4.模版总结

• 优点

        1.模版复用了代码，节省资源，更快的迭代开发，C++的标准模板库（STL）因此而产生

        2.增强了代码的灵活性

• 缺点

        1.模版会导致代码膨胀问题，也会导致编译时间变长

        2.出现模版编译错误时，错误信息非常凌乱，不易定位错误