C++~模板-泛型编程（函数模板，类模板，模板特化的使用和原理）

_Zebra

已于 2022-10-09 13:19:54 修改

阅读量673

点赞数 1

分类专栏： C++ 文章标签： c++ java 开发语言 c语言模板方法模式

于 2022-10-09 13:17:11 首次发布

本文链接：https://blog.csdn.net/qq_24016309/article/details/127223049

版权

C++ 专栏收录该内容

30 篇文章 1 订阅

订阅专栏

为什么函数模板不支持声明和定义放在两个文件中呢？

1.函数模板

（1）.函数模板的概念

函数模板代表了一个函数家族，该函数模板与类型无关，在使用时类型被参数化，根据实参类型产生函数的特定类型版本（实例化不同的函数）。

（2）.函数模板的格式

template<typename T1, typename T2,......,typename Tn>

返回值类型函数名(参数列表){}

比如我们可以实现一个swap模板函数，用于交换

template<typename T>
void Swap(T& a, T& b)
{
	T temp = a;
	a = b;
	b = temp;
}

注意：

1.typename是用来定义模板参数关键字，也可以使用class(切记：不能使用struct代替class)

2.注意：一个模板下只能有一个函数

3.模板传递的是类型，函数传递的是参数

1）.定义和声明分离

函数模板和类模板不支持声明和定义放到两个文件中，会出现链接错误

普通的函数和类的话是可以的

模板不支持声明和定义分别放到xxx.h和xxx.cpp中，一般是要放到一个文件中。有些地方就会命名成xxx.hpp，寓意就是头文件和定义实现内容合并—起但是并不是必须是.hpp，.h也是可以的，最好是.hpp

函数模板定义和声明分离：

定义和声明在同一个文件中，声明和定义的时候都需要加上模板参数列表

template<typename T>
void Swap(T& left, T& right);

//.......

template<typename T>
void Swap(T& a, T& b)
{
	T temp = a;
	a = b;
	b = temp;
}

类模板定义和声明分离：

成员函数声明

template<class T>
class Vector
{
public:
	Vector(size_t capacity = 10);
	void PushBack(const T& x);
private:
	T* _data;
	int _size;
	int _capacity;
};

成员函数定义（每个成员函数都要这么写，看清楚类域，都要加上）

template<class T>
Vector<T>::Vector(int capacity)
	: _data(new T[capacity])
	, _size(0)
	, _capacity(capacity)
{}

为什么函数模板不支持声明和定义放在两个文件中呢？

会出现链接错误

首先头文件中的声明会在两个文件中展开，然后在调用函数的文件中，看到有声明，认为只要声明的函数模板实例化一个函数，就可以正常运行，所以编译不会报错，此时call还不知道函数的地址，等着到链接的时候去符号表中找。

在定义函数模板的文件中，由于不知道T的具体类型，因此无法对函数模板和类模板进行实例化，从而也无法在符号表中生成函数名与函数地址的映射。

如果声明和定义放在同一个文件中，include以后，在函数调用的时候就能知道T的类型，从而对模板实例化，此时call的时候就知道对应函数的地址了，因为在同一个文件中，不需要通过编译链接去找了。

解决方案1:在template.cpp（定义模板的文件中）中针对于要使用的模板类型显示实例化，这样子编译器就知道T的类型了，能够成功实例化

例如在定义swap模板函数的文件中加上如下代码对其进行显示实例化

显示实例化指定
template
void Swap<int>(int& a, int& b);

解决方案2:在不要分离到两个文件中。直接写在xxx.hpp或xxx.h中

（3）.函数模板的原理

在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来自动推导生成对应类型的函数以供调用。

例如：当用int类型使用函数模板时，编译器通过对实参类型的推演，将T确定为int类型，然后产生一份专门处理int类型的代码，如swap函数，如果传入两个int类型的实参，编译器就会生成一个T都是int的swap函数。

（4）.函数模板的实例化

1. 隐式实例化：让编译器根据实参推演模板参数的实际类型

2. 显式实例化：在函数名后的<>中指定模板参数的实际类型

函数模板的类型一般是编译器根据实参传递给形参，推演出来的如果不能自动推演，那么我们就需要显示实例化，指定模板参数。

（5）.其他注意事项

1.函数/类模板参数可以有多个

2.函数参数的（隐式）匹配原则

1. 一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数

2. 对于非模板函数和同名函数模板，如果其他条件都相同（参数类型的数量，参数类型的种类数量和顺序等），在调动时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数，那么将选择模板

int Add(int left, int right) 
{
    return left + right; 
}

T1 Add(T1 a, T2 b)
{
    return a + b;
}

Add(3, 5); // 与非函数模板类型完全匹配，不需要函数模板实例化
Add(1, 2.66); // 模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的Add函数

3. 模板函数不允许自动类型转换（除非显示实例化），但普通函数可以进行自动类型转换

4. 模板参数可以缺省，具体方式和规则和函数参数缺省一样，必须从右往左给缺省值。

2.类模板

template<class T>
class Vector
{
public:
	Vector(size_t capacity = 10);
	void PushBack(const T& x);
private:
	T* _data;
	int _size;
	int _capacity;
};

使用（实例化）：

Vector<int> ans;

3.模板的特化

我们使用模板的时候，在有些情况下的不到我们所期望的效果，比如compare函数，比较传入参数的大小，左边参数小则返回true。

template<class T>
bool compare(T a, T b) 
{
    return a < b; 
}

对于绝大多数类型，都可以得到我们想要的效果。但是如果是下面的情况，我们希望的是两个A类型的对象根据其内部_a的值进行比较，但是此处比较的是指针的值，也就是两个对象地址的值。

class A{
public:
    A(int a){
        _a = a;
    }
    bool operator<(const A& aa){
        return _a < aa._a
    }

    int _a;
}


int main(){
    A a1(1);
    A a2(3);
    
    return 0;
}

此时，我们需要对模板进行特化。

（1）.函数模板的特化

函数模板的特化步骤：

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

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

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

4. 函数形参表: 必须要和模板函数的基础参数类型完全相同。

template<> 
bool compare<A*>(A* left, A* right) 
{ 
    return *left < *right; 
}

函数模板其实不常用，如果有需要，我们可以直接给出一个函数，语法更加简单，可读性更高

（2）.类模板的特化

类模板就必须要特化了，不能像重新写一个函数一样自己重新写一个类了。

1）.全特化

全特化就是将模板参数列表中所有的参数都确定化。

template<class T1, class T2>
class A
{
public:
    A() {cout<<"A<T1, T2>" <<endl;}
private:
    T1 _data1;
    T2 _data2;
};


template<>
class A<int, double> {
public:
    A() {cout<<"A<int, double>" <<endl;}
private:
    int _data1;
    double _data2;
};


int main()
{
    A<int, int> a1;
    A<int, double> a2;
    return 0;
}

2）.偏特化

1.半特化（部分特化）

template<class T>
class A<T, double> {
public:
    A() {cout<<"A<T, double>" <<endl;}
private:
    T _data1;
    double _data2;
};

2.参数有更严格限制的情况

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

template<class T1, class T2>
class A<T1*, T2*> {
public:
    A() {cout<<"A<T1*, T2*>" <<endl;}
private:
    T1* _data1;
    T2* _data2;
};


int main()
{
    A<int, int> a1;
    A<int8, int*> a2;  //此处会调用这里对指针类型特化的版本
    return 0;
}

_Zebra

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
C++~模板-泛型编程（函数模板，类模板，模板特化的使用和原理）

函数模板和类模板不支持声明和定义放到两个文件中，会出现链接错误普通的函数和类的话是可以的模板不支持声明和定义分别放到xxx.h和xxx.cpp中，一般是要放到一个文件中。有些地方就会命名成xxx.hpp，寓意就是头文件和定义实现内容合并—起但是并不是必须是.hpp，.h也是可以的，最好是.hpp。
复制链接

扫一扫