C++ Template 基础篇（一）：函数模板

港控/mmm° 2022-05-16 01:20 209阅读 0赞

Template所代表的泛型编程是C++语言中的重要的组成部分，我将通过几篇blog对这半年以来的学习做一个系统的总结，本文是基础篇的第一部分。

# 为什么要有泛型编程 #

C++是一门强类型语言，所以无法做到像动态语言（python javascript）那样子，编写一段通用的逻辑，可以把任意类型的变量传进去处理。泛型编程弥补了这个缺点，通过把通用逻辑设计为模板，摆脱了类型的限制，提供了继承机制以外的另一种抽象机制，极大地提升了代码的可重用性。

注意：模板定义本身不参与编译，而是编译器根据模板的用户使用模板时提供的类型参数生成代码，
    再进行编译，这一过程被称为模板实例化。用户提供不同的类型参数，就会实例化出不同的代码。

# 函数模板定义 #

把处理不同类型的公共逻辑抽象成函数，就得到了函数模板。

函数模板可以声明为inline或者constexpr的，将它们放在template之后，返回值之前即可。

### 普通函数模板 ###

下面定义了一个名叫compare的函数模板，支持多种类型的通用比较逻辑。

#include <iostream>
    using namespace std;
    
    
    template<typename T>
    int compare(const T& left, const T& right) {
        if (left < right) {
            return -1; 
        }
        if (right < left) {
            return 1; 
        }
        return 0;
    }
     
     
    int main()
    {
        compare<int>(1, 2);  //使用模板函数
        
        return 0;
    }

# 成员函数模板 #

不仅普通函数可以定义为模板，类的成员函数也可以定义为模板。

#include <iostream>
    using namespace std;
    
    
    class Printer {
    public:
        template<typename T>
        void print(const T& t)
        {
            cout << t <<endl;
        }
    };
    
    
     
     
    int main()
    {
        Printer p;
        p.print<const char*>("abc"); //打印abc
        
        return 0;
    }

# 为什么成员函数模板不能是虚函数(virtual)？ #

因为每个包含虚函数的类具有一个virtual table(vtable),包含该类的所有虚函数的地址，因此vtable的大小是确定的。成员函数模板只有被使用时才会被实例化，将其声明为虚函数会使vtable的大小不确定。所以，成员函数模板不能为虚函数。

# 实参推断 #

为了方便使用，除了直接为函数模板指定类型参数之外，我们还可以让编译器从传递给函数的实参推断类型参数，这一功能被称为模板实参推断。

# 如何使用 #

compare(1, 2); //推断T的类型为int
    compare(1.0, 2.0); //推断T的类型为double
    p.print("abc"); //推断T的类型为const char*

有意思的是，还可以通过把函数模板赋值给一个指定类型的函数指针，让编译器根据这个指针的类型，对模板实参进行推断。

int (*pf) (const int&, const int&) = compare; //推断T的类型为int

# 当返回值类型也是参数时 #

当一个模板函数的返回值类型需要用另外一个模板参数表示时，你无法利用实参推断获取全部的类型参数，这时有两种解决办法：

(1) 返回值类型与参数类型完全无关，那么就需要显示的指定返回值类型，其他的类型交给实参推断。

注意：此行为与函数的默认实参相同，我们必须从左向右逐一指定。

template<typename T1, typename T2, typename T3>
    T1 sum(T2 v2, T3 v3) {
      return static_cast<T1>(v2 + v3);
    }
    
    auto ret = sum<long>(1L, 23); //指定T1, T2和T3交由编译器来推断
    
    template<typename T1, typename T2, typename T3>
    T3 sum_alternative(T1 v1, T2 v2) {
      return static_cast<T1>(v1 + v2);
    }
    auto ret = sum_alternative<long>(1L, 23); //error，只能从左向右逐一指定
    auto ret = sum_alternative<long,int,long>(1L,23); //ok, 谁叫你把最后一个T3作为返回类型的呢？

(2) 返回值类型可以从参数类型中获得，那么把函数写成尾置返回类型的形式，就可以愉快的使用实参推断了。

template<typename It>
    auto sum(It beg, It end) -> decltype(*beg) {
      decltype(*beg) ret = *beg;
      for (It it = beg+1; it != end; it++) {
         ret  = ret + *it;
      }
      return ret;
    }
    
    vector<int> v = {1, 2, 3, 4};
    auto s = sum(v.begin(), v.end()); //s = 10

# 实参推断时的自动类型转换 #

编译器进行模板实参推断时通常不会对实参进行类型转换，只有以下几种情况例外：

(1) 普通对象赋值给const引用 int a = 0; -> const T&  
(2) 数组名转换为头指针 int a\[10\] = \{0\}; -> T\*  
(3) 函数名转换为函数指针 void func(int a)\{...\} -> T\*

# 函数模板重载 #

函数模板之间，函数模板与普通函数之间可以重载。编译器会根据调用时提供的函数参数，调用能够处理这一类型的最特殊的版本。在特殊性上，一般按照如下顺序考虑：

(1) 普通函数

(2) 特殊模板（限定了T的形式的，指针、容器等）

(3) 普通模板（对T没有任何限制的）

对于如何判断某个模板更加特殊，原则如下：如果模板B的所有实例都可以实例化模板A，而反过来则不行，那么B就比A特殊。

#include <iostream>
    using namespace std;
    
    
    template<typename T>
    void func(T& t) { //通用模板函数
        cout << "In generic version template " << t << endl;
    }
     
    template<typename T>
    void func(T* t) { //指针版本
        cout << "In pointer version template "<< *t << endl;
    }
     
    void func(string* s) { //普通函数
        cout << "In normal function " << *s << endl;
    }
     
    
    
     
    int main()
    {
        int i = 10;
        
        func(i);            //调用通用版本，其他函数或者无法实例化或者不匹配
        func(&i);           //调用指针版本，通用版本虽然也可以用，但是编译器选择最特殊的版本
        string s = "abc";
        func(&s);           //调用普通函数，通用版本和特殊版本虽然也都可以用，但是编译器选择最特化的版本
        func<>(&s);         //调用指针版本，通过<>告诉编译器我们需要用template而不是普通函数
        
        return 0;
    }

# 模板函数特化 #

有时通用的函数模板不能解决个别类型的问题，我们必须对此进行定制，这就是函数模板的特化。函数模板的特化必须把所有的模版参数全部指定。

#include <iostream>
    using namespace std;
    
    
    
    template<typename T>
    void func(T& t)
    {   
        // 通用模板函数
        cout << "In generic version template " << t << endl;
    }
     
    
    // 函数模板全特化,必须先存在函数模板, 才可以进行全特化
    template<>
    void func(int& i) 
    {
        cout << "In special version for int "<< i << endl; 
    }
    
    
     
    int main()
    {
        int i = 10;
        func(i); //调用特化版本
        
        return 0;
    }

**本文转自：**

**[https://blog.csdn.net/lezardfu/article/details/56852043][https_blog.csdn.net_lezardfu_article_details_56852043]**

[https_blog.csdn.net_lezardfu_article_details_56852043]: https://blog.csdn.net/lezardfu/article/details/56852043