当前位置：首页 > news >正文

模板--进阶

news 来源：原创 2025/4/29 16:52:51

1. 非类型模板参数

模板解决了两类问题

1控制数据类型

2控制某种设计逻辑

类域可以直接访问什么？

1static修饰的静态成员变量

2typedef定义的内嵌类型

3 内部类

下面我们就要引出一个模板的知识点----------再用类模板的时候从类模板里面去取东西的时候

要在模板参数Container前面加上typename!

原因是：编译不确定Container::const_iterator是类型还是对象

typename就是明确告诉编译器这里是类型，等模板实例化再去找，或者用auto代替（auto已经表明是类型了）

有一个原则：没有实例化的模板不能用域作用限定符去取东西

因为这时候编译器不知道你取出的东西是什么可以是typedef定义的内嵌类型或者内部类，但是如果是取的是静态成员变量和对象的话就就会报错（静态成员变量不支持后面的操作，对象也是不合法的）

所以以后要去取东西的时候就要加typename

模板参数分类：类型形参与非类型形参。

class 和typename是有区别的（一般用的时候是一样的）

类型形参即：出现在模板参数列表中，跟在class或者typename之类的参数类型名称。

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

//这两个就是类型参数和非类型参数
template <class T,size_t N>
class array
{
public:T& operaotr[](size_t n){return _a[n];}
private:T _a[N];size_t size;
};

这个参数是常量而且必须是整形，因为非类型模板参数一般用来使用来定义静态数组

非类型就是变量，按需实例化（调用了才会去实例化）

array这个容器就用到了非类型模板参数

这是c++11出来的比较鸡肋的东西

array其实就是一个数组，我们自己搞得数组和array他俩都能支持同样的操作，同样不初始化

array唯一的有事就是对越界的检查就比较严格，越界读写都能检查，普通数组就不能检查

那么问题来了，用vector 不香吗

注意：

1. 浮点数、类对象以及字符串是不允许作为非类型模板参数的。

2. 非类型的模板参数必须在编译期就能确认结果。

2. 模板的特化

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

2.1函数模板的特化

// 函数模板 -- 参数匹配
template<class T>
bool Less(T left, T right)
{return left < right;
}// 对Less函数模板进行特化
template<>
bool Less<Date*>(Date* left, Date* 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;
}

1. 必须要先有一个基础的函数模板

2. 关键字template后面接一对空的尖括号<>

3. 函数名后跟一对尖括号，尖括号中指定需要特化的类型

4. 函数形参表: 必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误。

函数模板的特化，可以去写特化来解决问题或者再写一个构成函数重载

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

该种实现简单明了，代码的可读性高，容易书写，因为对于一些参数类型复杂的函数模板，特化时特别给出，因此函数模板不建议特化

2.2类模板的特化

但是类模板不同，必须要去走特化

类模板的特化其实就是对原来的类进行特殊处理

根据你传的东西编译器去判断是走正常的还是特殊处理过的，就像传指针日期类的比较

正常是要传这两个vector<Date*> PLess<Date>的，但是很麻烦，我们可以通过特化，检测到是Date*就走特化的处理

2.3特化的分类

1全特化

就是将模板参数列表里面所有的参数都确定化

2偏特化

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

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

1部分特化将模板参数类表中的一部分参数特化。

2参数更进一步的限制偏特化并不仅仅是指特化部分参数，而是针对模板参数更进一步的条件限制所设计出来的一个特化版本。（就像将两个参数都限定为指针或者引用）

template <class T1,class T2>
class Date
{
public:Date(){cout << "Date<T1,T2>" << endl;}
};
//全特化
template <>
class Date<int ,char>
{
public:Date(){cout << "Date<int ,char>" << endl;}
};template <class T1,class T2>
class Date<T1*, T2*>
{
public:Date(){cout << "Date<T1*, T2*>" << endl;}
};
template <class T1, class T2>
class Date<T1&, T2&>
{
public:Date(){cout << "Date<T1&, T2&>" << endl;}
};
//偏特化
template <class T1>
class Date<T1, char>
{
public:Date(){cout << "Date<T1, char>" << endl;}
};int main()
{Date<int, int> d1;Date<int, char> d2;Date<double, char> d3;Date<int*, int*> d4;Date<int&, int&> d5;return 0;
}

其实特化严格上不是一个新的类，不能独立存在，但是实例化的东西是一个不同的类型，这些类根据你的需求自己再去设计（对特殊情况特殊处理）可能用不到原来的类的所有功能，就可以光实现想用的功能

3. 模板的分离编译

我们之前实现的一系列容器，我们都是把定义写到.h文件中，而我们在c语言实现这些东西的时候

都是声明和定义分离，这是为什么呢？

程序测试代码

Stack.cpp


#include "Stack.h"
namespace cy
{template <class T,class Container>void stack<T, Container>::push(const T& x){_con.push_back(x);}template <class T, class Container>void stack<T,Container>::pop(){_con.pop_back();}void A::func1(int i){}
}

Stack.h

#include <vector>
namespace cy
{//容器适配器template <class T,class Container=std::vector<T>>class stack{public:void push(const T& x);void pop();T& top(){return _con.back();}size_t size(){return _con.size();}bool empty(){return _con.empty();}private:Container _con;};class A{public:void func1(int i);//void func2();};}

Test.cpp

#include <iostream>
#include <array>
#include<vector>
using namespace std;
#include "Stack.h"int main()
{cy::stack<int> s1;s1.push(1);return 0;
}

显而易见，会报错，可是我们写了定义啊

主要的原因就是用了模板，模板没有实例化，尽管有定义，但是不能生成地址

这与我们之前讲的函数名修饰规则一样，你模板都没实例化编译器怎么去修饰，当然就没定义了

没有用模板的话，只有函数有定义，编译阶段才会生成地址，只有声明相当于就是一个承诺，这样编译就不会报错，而到链接的时候就会去找，这是如果没有地址就会报链接错误

解决方法

1. 将声明和定义放到一个文件 "xxx.hpp" 里面或者xxx.h其实也是可以的。推荐使用这种。

2. 模板定义的位置显式实例化。这种方法不实用，不推荐使用。

#include "Stack.h"
namespace cy
{template <class T,class Container>void stack<T, Container>::push(const T& x){_con.push_back(x);}template <class T, class Container>void stack<T,Container>::pop(){_con.pop_back();}void A::func1(int i){}
//就是这样显示实例化templatestack<int>;
}

这样显示实例化很不方便，用一个类型就要显示实例化一个类型