提供了编程的基础技术教程

zl程序教程

您现在的位置是：首页 >  Java

当前栏目

函数新手的冷门——函数模板（全：包括实例化和具体化）

2023-02-18 16:26:29 时间

可能有的人像以前的码神一样，学了一年多都不知道函数模板究竟是个什么东东，究竟有什么用，这可谓是秋名山一路下来，不知道有个排水渠过湾一样，哈哈，话不废话，直接上正题了。 定义 函数模板不是一个实在的函数，编译器不能为其生成可执行代码。定义函数模板后只是一个对函数功能框架的描述，当它具体执行时，将根据传递的实际参数决定其功能。 这他妈的，god知道是什么东西啊！

那就写用法吧： 这里引用c++primer中的一个案例swap函数

void swap(int &a,int &b)//int 
{
	int temp;
	temp=a;
	a=b;
	b=temp;
}
void swap1(double &a,double &b)
{
	int temp;
	temp=a;
	a=b;
	b=temp;
}

可以看出，我为了实现交换的操作，需要写俩个函数，尽管他们的用途几乎是一致的，此时周董的黑白ae86——函数模板就来了，再看：

template <class T>
void Swap(T & x, T & y)
{
    T tmp = x;
    x = y;
    y = tmp;
}

这个就是函数模板，书中的解释是这样的 T 是类型参数，代表类型。编译器由模板自动生成函数时，会用具体的类型名对模板中所有的类型参数进行替换，其他部分则原封不动地保留。同一个类型参数只能替换为同一种类型。编译器在编译到调用函数模板的语句时，会根据实参的类型判断该如何替换模板中的类型参数。

下面给大家写一个完整的模板

#include <iostream>
using namespace std;
template<class T>
//其中class可以替换为typename
//template<typename T>
void swap(T & x, T & y)
{
    T tmp = x;
    x = y;
    y = tmp;
}
int main()
{
    int n = 1, m = 2;
    swap(n, m);  //编译器自动生成 int 函数
    double f = 1.2, g = 2.3;
    swap(f, g);  //编译器自动生成  double 函数
    return 0;
}

其中的原理就是，编译器找不到，函数Swap的类型，但是发现，我们传入的n，m都是int类型，所以自己用int来代替函数模板中的T

要实现函数模板的理解，我们还应该了解专业术语：

  1. 实例化：1 实例化 实例化有两种形式，分别为显式实例化和隐式实例化。模板并非函数定义，实例式函数定义。

1.1 显式实例化（explicit instantiation） 显式实例化意味着可以直接命令编译器创建特定的实例，有两种显式声明的方式。

比如存在这么一个模板函数

template void Swap(T &a, T &b)

第一种方式是声明所需的种类，用<>符号来指示类型，并在声明前加上关键词template，如下： template void Swap(int &, int &);

第二种方式是直接在程序中使用函数创建，如下：

Swap(a,b);

显式实例化直接使用了具体的函数定义，而不是让程序去自动判断。

1.2 隐式实例化（implicit instantiation） 隐式实例化比较简单，就是最正常的调用，Swap(a,b)，直接导致程序生成一个Swap()的实例，该实例使用的类型即参数a和b的类型，编译器根据参数来定义函数实例。

  1. 具体化：思考这么一个问题，当前的Swap模板交换输入的两个对象，可能式基本类型也可能式自定义类。如果有这么一个需求，需要交换自定义类里的某一个属性而不是整个类，那么Swap模板就不可用，因为Swap模板交换的是整个类。 显式具体化将不会使用Swap()模板来生成函数定义，而应使用专门为该特定类型显式定义的函数类型。有两种定义形式，如下，其中job为用户自定义类 template <> void Swap(job &a, job &b) template <> void Swap(job &a, job &b) 显式具体化在声明后，必须要有具体的实现，这是与显示实例化不同的地方。

下面我们再来模仿一个程序来具体看一下

#include<iostream>
#include<string>
using namespace std;
 
struct job
{
    string name;
    int salary;
    job(string _name,int _salary):name(_name),salary(_salary){};
};
 
//template prototype
template <typename T>
void Swap(T &a, T &b){
    T temp;
    temp = a;
    a = b;
    b = temp;
}
 
//explict specialization for job 显式具体化
template <> void Swap(job &a, job &b)
{
    int temp;
    temp = a.salary;
    a.salary = b.salary;
    b.salary = temp;
}
 
template void Swap<int>(int &, int &);
int main()
{
    char a = 'a', b = 'b';
    cout<<"a: "<<a<<" ; b: "<<b<<endl;
    Swap(a,b);  //1 implicit template instantiation for char 隐式实例化
    cout<<"a: "<<a<<" ; b: "<<b<<endl;
 
    int c = 1, d = 2;
    cout<<"c: "<<c<<" ; d: "<<d<<endl;
    Swap(c,d);  //2 use explicit template instantiation for int 显式实例化
    cout<<"c: "<<c<<" ; d: "<<d<<endl;
   
    Swap<int>(c,d);  //3 use explict template instantiation for int 显式实例化
    cout<<"c: "<<c<<" ; d: "<<d<<endl;
    
    job e("lucy",100), f("bob",200);
    cout<<"lucy: "<<e.name<<" "<<e.salary<<" ; bob: "<<f.name<<" "<<f.salary<<endl;
    Swap(e,f);  //use explict specialization for job 调用显式具体化
    cout<<"lucy: "<<e.name<<" "<<e.salary<<" ; bob: "<<f.name<<" "<<f.salary<<endl;
}

如果感觉不错，欢迎点赞评论！

相关文章