C/C++编程：模板实参演绎的过程

野性酷女 2023-01-14 10:52 117阅读 0赞

# 为什么需要模板实参演绎 #

在某个函数模板的调用中，如果都显式的指定模板实参(比如`concat<std::string, int>(s, 3)`)，那么会导致代码繁琐。但是，可以借助模板实参演绎过程，自动确定这些所需要的模板实参

# 演绎的过程 #

针对一个函数调用，演绎过程会比较**调用实参的类型**和**函数模板对应的参数化类型(即T)**，然后针对要被演绎的一个或者多个参数，分别推倒出正确的替换。我们应该记住：**每个实参-参数对的分析都是独立的**。因此，如果最后得出的结论发生矛盾，那么演绎将会失败：

template<typename T>
    T const& max(T const &a, T const& b){
        
    	return a < b ? a : b;
    }
    
    int g = max(1, 1.0);

第一个实参类型是int，因此max()模板的参数T被暂时演绎成T，而第2个推导出来的T是double类型，两者冲突，演绎失败。注意，这里**演绎失败了不代表这个程序是无效的**，如果有符合演绎的重载程序就是成功的。

即使所有的演绎的模板参数都可以被一致性的确定，演绎过程也可能失败。这种情况就是：**函数声明中，进行替换的模板实参可能会导致无效的构造**。例如：

template<typename T>
    typename T::ElementT at(T const & a, int i){
        
        return a[i];
    }
    
    void f(int *p){
        
        int x = at(p, 7);
    }

![在这里插入图片描述][20210420145354422.png]  
在此，T被演绎成`int *`，然而，在返回类型T::ElementT，用`int*`来替换T之后，会导致一个无效的C++构造，从而也使得这个演绎过程失败。

> 实参-参数对是如何匹配的

匹配类型A(来自实参的类型)和参数化类型P（来自参数的声明）

*  如果被声明的参数是一个引用类型(即T&)，那么P就是所引用的类型(即T)，而A是实参类型。 否则，P是所声明的参数类型，A是实参的类型
 *  如果实参的类型是数组或者函数类型，还会发生decay转型，转换为对应的指针类型，同时会忽略高层次的const和volatile限定符

template<typename T> void f(T); // P是T
    
    template<typename T> void g(T &);   // P是T
    
    double x[10];
    int const i = 7;
    
    f(x);  // 非引用参数：T是double *
    g(x);  //引用参数： T是doubel[20]
    f(i); // 非引用参数： T是int
    g(i);  //引用参数： T是int const
    f(7);  // 非引用参数： T是int
    g(7);    //引用参数： T是int --》 错误：不能把7传递给int&

**decay是一个概念，指的是从数组和函数类型到指针类型的隐式转换**

一般来讲，**对于引用参数，绑定到该参数的实参是不会进行decay的**。但是如果实参是字符串类型，结果就可能不同了。

template<typename T>
    T const& max(T const &a, T const& b);

对于`max("Apple", "Pear")`， "Apple"的类型是char const\[6\], "Pear"是const char\[5\]，不存在数组到指针的decay（因为要演绎的参数是引用参数）；因此会演绎失败

[20210420145354422.png]: /images/20221022/e958e0c45526436691bf0497dacafc5c.png