模板与泛型编程1（函数模板）

雨点打透心脏的1/2处 2023-05-30 01:28 20阅读 0赞

定义、实例化函数模板：

对于函数体完全相同，唯一差异就是参数类型的情况，我们可以定义一个通用的函数模板，而非为每个类型都定义一个新函数：

#include<bits/stdc++.h>
    using namespace std;
    template <typename T> int cmp(const T&v1,const T&v2){ 
        if(v1<v2)return -1;
        if(v1>v2)return 1;
        return 0;
    }
    int main(){ 
        cout<<cmp(1,0);
    }

注意：模板定义以关键字 template 开始，后跟一个模板参数列表，里面有一个或多个模板参数。在模板定义中，**模板参数列表不能为空**

类似于函数参数，模板参数表示在类或函数定义中用到的类型或值。当使用模板时，我们 (隐式的或显  
式地) 指定模板实参，将其绑定道模板参数上。

当我们**调用一个函数模板时，编译器（通常）用函数实参来为我们推断模板实参**，并用推断出的模板参数来为我们实例化一个特定版本的函数。  
**模板参数可以是模板类型参数或非类型模板参数（表示值而非类型）**

**模板类型参数：**

前面的 compare 中 T 就是一个模板类型参数。一般来说我们可以将类型参数看作类型说明符，就像内置类型或类类型说明符一样使用：

template <typename T>//类型参数
    //函数模板返回类型与参数类型相同
    T foo(T *p) { //类型参数可硬用来指定返回类型或函数的参数类型
        T tmp = *p;//类型参数可以用于函数体内部声明变量或类型转换
        //...
        return tmp;
    }

类型参数前必须使用关键字 class 或 typename：

#include<bits/stdc++.h>
    using namespace std;
    template<class T,typename U>;//正确
    template<class T1,U1>;//错误

注意：在模板参数列表中，class 和 typename 含义完全相同，可以互换使用  
**非类型模板**

#include<bits/stdc++.h>
    using namespace std;
    //非类型参数表示一个值而非一个类型，我们通过一个特定的类型名来指定费类型参数
    //实例化时：参数被一个值代替
    template <unsigned N,unsigned M>
    int cmp(const char (&p1)[N],const char (&p2)[M]){ 
        return strcmp(p1,p2);
    }
    //上述：int cmp(const char (&p1)[3], const char (&p2)[4])
    int main(){ 
    }

注意：一个非类型参数可以是一个整型，或者是一个指向对象或函数类型的指针或（左值）引用

绑定到非类型整型参数的实参必须是一个常量表达式。绑定到指针或引用非类型参数的实参必须具有静态的生存期。指针参数也可以用 nullptr 或一个值为 0 的常量表达式来实例化（常量表达式或者静态变量）

**inline 和 constexpr 的函数模板：**

template inline T min(const T&, const T&);  
注意：inline 或 constexpr 说明符放在模板参数列表之后，返回类型之前

#include<bits/stdc++.h>
    using namespace std;
    template <unsigned N,unsigned M>
    inline int cmp(const char (&p1)[N],const char (&p2)[M]){ 
        return strcmp(p1,p2);
    }//注意inline的位置
    int main(){ 
    }

#### 模板编译： ####

**当编译器遇到一个模板定义时，它并不生成代码。只有当我们实例化（使用）模板的特定版本时，编译器才会生成代码。**  
通常，当我们调用一个函数时，编译器只需要掌握函数的声明。类似的，当我们使用一个类型的对象时，类定义必须是可用的。但成员函数的定义不必已经出现。因此我们可以将类定义和函数声明放在头文件中，而普通函数和类的成员函数的定义放在源文件中。  
也就是：使用函数和类的时候，只要生命过，类定义过。不必使用。  
**模板则不同：为了生成一个实例化版本，编译器需要掌握函数模板或类模板成员函数的定义。因此，与非模板代码不同，模板的头文件通常既包括声明也包括定义。**  
也就是：使用的模板必须是定义过的。

**大多数编译错误发生在实例化期间报告：**  
如，前面的 compare 函数，如果我们用一个没有定义 < 运算符的类型实例化该函数模板，则会发生编译错误

手写find函数：

#include<vector>
    #include<list>
    #include<iostream>
    using namespace std;
    template<typename T,typename U>
    T find(const T&bg,const T&ed,const U val){ 
        auto cnt=bg;
        while(cnt!=ed){ 
            if(*cnt==val)return cnt;
            cnt++;
        }
        return cnt;
    }
    int main(){ 
        vector<int> vt={ 1,2,3,4,5};
        auto cnt=find(vt.begin(),vt.end(),5);
        cout<<*cnt<<endl;
        list<string> ls={ "aaa","bbb","ccc","ddd"};
    
        auto xx=find(ls.begin(),ls.end(),"ccc");
        cout<<*xx<<endl;
    }

编写接受一个数组引用参数的 print 模板：

#include<bits/stdc++.h>
    using namespace std;
    template<typename T,unsigned N>
    void print(const T (&t1)[N]){ 
        for(int i=0;i<N;i++)cout<<t1[i]<<" ";cout<<endl;
    }
    
    int main(){ 
        int a[10]={ 2,3,4,5};
        print(a);
        string b[2]={ "aaa","bbb"};
        print(b);
        int *c=&a[2];
        print(c);//注意：只能传数组，不能传指针
    }

定义接受一个数组实参的 begin、end 模板：

//编写一个接受数组实参的begin和end函数
    #include<bits/stdc++.h>
    using namespace std;
    template<typename T,unsigned N>
    T* begin_(const T(&a)[N]){ 
        return const_cast<T*>(a);
    }
    template<typename T,unsigned N>
    T* end_(const T(&a)[N]){ 
        return const_cast<T*>(a+N);
    }
    template<typename T,unsigned N>
    void print(const T(&t)[N]){ 
        for(int i=0;i<N;i++)cout<<t[i]<<" ";cout<<endl;
    }
    int main(){ 
        int a[10]={ 1,2,4,5,66,9};
        sort(begin_(a),end_(a));
        print(a);
    }

编写一个 constexpr 模板，返回给定数组的大小：

#include<bits/stdc++.h>
    using namespace std;
    template<typename T,unsigned N>
    constexpr size_t siz(const T(&t)[N]){ 
        return N;
    }
    class Node{ 
        int x;
    };
    int main(){ 
        Node a[100];
        cout<<siz(a);
    }