稍微深入函数模板

拼搏现实的明天。 2022-07-11 09:15 127阅读 0赞

# C++中的函数新特性（二） #

1.  浅谈函数模板和泛型编程
2.  函数模板的实现原理
3.  扩展：模板重载简介
4.  局限性：模板的具体化
5.  局限性：模板实例的选择
6.  函数的选择
7.  局限性：类型的判定

# 函数模板 #

## 浅谈函数模板与泛型编程 ##

> 泛型编程  
> 通过一种语言机制  
> 实现一个通用的方法（标准容器库）  
> 通用是指：每一种数据类型都能用

### 函数模板怎么实现泛型编程呢？ ###

上次的例子：  
如果我要打一个交换两个int变量的函数  
我可以这样

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

如果通过函数模板来实现泛型编程  
则可以这样

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

> 关键字：template（模板）  
> 关键字：typename

第一行，指出这是一个函数模板  
一个可替代的变量类型，我们暂且命名为T  
然后后面函数的定义  
就用T来代替具体的类型  
之后我们的函数调用  
就可以用这一个swap函数，去交换int变量  
去交换double变量

> 实际上函数模板就是在编译的时候  
> 将T换成所需要的类型  
> 就像 typedef T int ；一样

**所以我们在调用这个函数的时候**  
**可以这样调用**

double a,b;
    swap(a,b);
    int c,d;
    swap(c,d);

然后就达到了泛型编程的目的  
对，无论什么类型，都可以调用  
吗？  
。  
。  
。  
当然，事情并没有那么简单。  
数据类型，远远不止这几种基本类型  
还有结构体，还有类  
还有……………………  
这个在后面的局限性里拓展一下

## 函数模板的实现原理 ##

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

函数模板的语法  
template是模板的关键字  
typename是在模板中说明类型的关键字  
`template < typename T >`  
在第一行中，先声明了一个类型参数T  
然后在函数的具体定义中，  
把需要用到该类型的全部用T

> 原理：  
> 在编译过程  
> 编译器会自动根据函数的调用情况  
> 知道需要使用哪种类型的函数  
> 然后就会  
> **直接把T替换成对应的类型**  
> 生成一个新函数

所以，在编译过程，  
模板就会变成真正的函数  
(这个过程叫做**模板的实例化**)  
在编译过后，程序就没有模板了  
只有对应的函数

## 模板的重载 ##

同函数一样，模板也是可以重载的  
(还记得什么叫函数的重载吗？)  
(C++中允许同名函数的存在)  
(虽然同名，不过会根据函数的特征标选择)  
(所以不会产生冲突)

> 模板重载  
> 同名函数模板  
> 在C++中是允许存在的  
> 前提是**模板的参数**不同

先放个例子

template <typename T >
    T add(T a, T b)
    {
        return a+b;
    }

对这个模板，  
我们可以使两个相同类型的变量相加  
然后返回他们的和

template <typename T1， typename T2 >
    T1 add(T1 a, T2 b)
    {
        return a+b;
    }

对这个模板  
我们可以使两个具有不同类型的变量相加  
并且返回第一个变量所具有的类型  
当然，我们还可以这样

template <typename T，int t >
    T add(T a, T b)
    {
        return a+b+t;
    }

而这个模板，我们可以在模板参数里  
放入一个int类型的整数  
然后相加的时候加多一个数

## 模板局限性1： ##

> 如果模板对某一种类型不合适  
> 可以自己另外定义一个函数代替模板吗

假设我现在有这样一个模板

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

然后我有这样一种  
用结构体定义的数据类型

struct person{
        char name[40];
        int age;
    }；

我能否这样？

person p1,p2;
    // after initialization
    swap( p1, p2 );

虽然C++允许结构体的赋值  
可是，如果我只想交换age这一个变量呢  
只想交换年龄而不改名可以吗？

### 模板的显式具体化技术 ###

我们想做的事情就是  
想让一个模板，对其余的所有类型都适用  
唯独用person类型的时候  
我想另外定义一个而不使用模板的定义  
**这里，我们使用模板的显式具体化技术**

> 具体化：  
> 就是对某一种类型给出具体的定义

这里我先给出person类型的显式具体化例子

//函数原型
    template <> 
    void swap<person>(person & a, person & b);
    //函数定义
    template <> 
    void swap<person>(person & a, person & b)
    {
        int temp;
        temp = a.age;
        a.age = b.age;
        b.age = temp;
    }

对比普通模板

//函数原型
    template <typename T >
    void swap(T & a, T & b)；
    //函数定义
    template <typename T >
    void swap(T & a, T & b)
    {
        T temp;
        temp = a;
        a = b;
        b = temp;
    }

**区别1：template还在**  
但是后面的<>中可自定义的类型参数没有了  
也就是说没有了可自定义的类型参数  
**区别2：函数名**  
函数名后面加上了< person >  
表明这是该模板下该类型的定义  
**区别3：形参列表及函数定义**  
没有了自定义的类型参数  
后面的一切操作  
都是由具体的类型完成

> 函数的具体化  
> 使得在调用函数的时候  
> 能够根据类型，选择使用模板函数  
> 还是用**模板函数下的具体化**

## 模板局限性2： ##

假设有这样一种模板函数

template <typename T >
    T add(T a, T b)
    {
        return a+b;
    }

> 问题描述  
> 使这个模板函数这样调用
> 
>     int   a = 2;
>     double d = 3.0;
>     add(a,d);
> 
> 模板函数该如何选择类型？

这里我们需要用到模板的另一种语法

### 模板的实例化技术 ###

什么是实例化？

> 就是从模板变成真正的函数  
> 实例化分为  
> 隐式实例化和显式实例化

#### 隐式实例化 ####

在前面的原理中我们说到  
模板在编译过程就会变成真正的函数  
在编译后  
代码是没有模板这一种东东的  
模板，已经变成了一个一个的函数  
如果以上面的swap函数为例  
我一旦调用swap函数

int a = 2;
    int b = 3;
    add(a,b);