C++基础7:模板编程/泛型编程相关

最新推荐文章于 2022-05-09 16:20:46 发布

阿华田咯

最新推荐文章于 2022-05-09 16:20:46 发布

阅读量96

点赞数

本文链接：https://blog.csdn.net/weixin_42278523/article/details/105921679

版权

1. 基本概念

1.0 c++学习的四个阶段

a. c语言；
b. 面向对象；
c. 模板/泛型编程；
d. 高级应用；

1.1 什么是模板？

模板(Template)是允许函数或者类通过泛型(generic types)的形式表现或运行的特性。
模板前的编程的数据必须要有数据类型；
模板则把类型作为变量；

1.2 模板有什么用？

模板可以使函数或者类只写一份代码而对应不同的类型。

1.3 模板编程/泛型编程

一种独立于特定类型的编码方式

1.4 模板分类

模板分为函数模板与类模板两类。

函数模板(Function template):使用泛型参数的函数(function with generic parameters)
类模板(Class template):使用泛型参数的类(class with generic parameters)

2. 函数模板

模板声明

template <模板形参表> 函数返回类型 函数(形参表);

模板定义

template <模板形参表>
函数返回类型 函数(形参表){
      函数体;
};

例如：

template <typename T> T Max(T a,T b){
        return a>b?a:b;
}

模板实例化

函数(实参表)

产生模板特定类型的函数或者类的过程称为实例化
调用函数模板与调用函数完全一致。

实例

#include <iostream>
using namespace std;

template<typename T>
T Max(T a,T b){
	return a>b?a:b;
}

int main(){
	// 指定类型
	cout << Max<int>(10,13) << endl;
	cout << Max<float>(10.01F,10.1F) << endl;
	cout << Max<double>(10.01,10.1) << endl;
	cout << Max<string>(string("abc"),string("def")) << endl;
	cout << Max<string>("abc","def") << endl;
	// 自动推导
	cout << Max(10,13) << endl;
	cout << Max(10.01F,10.1F) << endl;
	cout << Max(10.01,10.1) << endl;
	cout << Max(string("abc"),string("def")) << endl;
	cout << Max("abc","def") << endl;
}

3. 类模板

模板声明

template <模板形参表> class 类名;

模板定义

template <模板形参表>
class 类名 {
}

模板实例化

类名<模板实参表> 对象;

模板参数表
多个模板参数之间,分割。模板参数,模板参数,…
模板参数
类型形参
class 类型形参或者 typename 类型形参

类模板的声明与实现通常都写在头文件中，是不能够分开的。

实例

#include <iostream>
#include <cstring> // strcmp()
using namespace std;

template<typename T,int n>
void Show(T m){
    if(n==1){
        cout << oct << m << endl;
    }else if(n==2){
        cout << dec << m << endl;
    }else {
        cout << hex << m << endl;
    }
}

template<typename T>
void PrintArr(T* arr,int n){
    for(int i=0;i<n;++i){
        cout << arr[i] << " ";
    }
    cout << endl;
}

template<typename T,int n>
void PrintArr(T (&arr)[n]){
    for(int i=0;i<n;++i){
        cout << arr[i] << " ";
    }
    cout << endl;
}
// 把模板类型分开
/*
template<typename T,typename U>
T Max(T a,U b){
    return a>b?a:b;
}*/
template<typename T>
const T& Max(const T& a,const T& b){
    return a>b?a:b;
}
// 特化成指针类型
template<typename T>
    const T* Max(const T* a,const T* b){
    return *a > *b?a:b;
}
// 特化成字符数组
template<>
const char* Max(const char* a,const char* b){
    return strcmp(a,b)>0?a:b;
}

int main(){
    // 指定类型
    cout << Max<int>(10,13) << endl;
    cout << Max<float>(10.01F,10.1F) << endl;
    cout << Max<double>(10.01,10.1) << endl;
    cout << Max<string>(string("abc"),string("def"))<< endl; // 可以不可以使用const string&?
    cout << Max<string>("abc","def")<< endl;

    // 自动推导
    cout << Max(10,13) << endl; // Max<int>()
    cout << Max(10.01F,10.1F) << endl; // Max<float>()
    cout << Max(10.01,10.1) << endl; // Max<double>()
    cout << Max(string("abc"),string("def"))<< endl; // Max<string>()
    cout << Max("abc","def")<< endl; // 为什么结果不正确？ // Max<char*>()
    // 不能自动推导的情况
    cout << Max((double)10,13.1) << endl; // 强制类型转换，保证类型一致
    cout << Max<double>(10,13.1) << endl; // 显示实例化
   
    int a = 25;
    int b = 20;

    cout << *Max(&a,&b) << endl; // Max<int>(int*,int*)

    const char* str = "abcd";
    cout << *Max(str,str+1) << endl; // Max<char>(char*,char*)

    // 非类类型模板参数，使用的时候非类类型模板参数必须使用常量赋值，不能使用变量。
    Show<int,1>(100);
    Show<int,2>(100);
    Show<int,3>(100);
    // int n = 1;
    // Show<int,n>(100);
    {
    int arr[] = {1,2,3,4,5};
    //PrintArr(arr,sizeof(arr)/sizeof(arr[0]));
    // PrintArr<int,sizeof(arr)/sizeof(arr[0])>(arr);
    PrintArr(arr);
    }
    {
    float arr[] = {1.1,2.2,3.3,4.4,5.5};
    PrintArr(arr);
    }
}

4. 模板参数推导/推演(deduction)

模板参数推导/推演(deduction):由模板实参类型确定模板形参的过程。

实例化有两类：
显示实例化：代码中明确指定类型的实例化
隐式初始化：根据参数类型自动匹配的实例化

类模板参数允许自动类型转换(隐式转换);函数模板参数不允许自动类型转换(隐式转换)
在模板参数列表中，class 和typename 完全一样。但是在语义上，class 表示类，typename 代表所有类型(类以及基本类型)。
请尽量使用 typename

函数模板实参类型不一致问题

template <typename T> 
inline const T& Max(const T& a, const T& b){
        return a>b?a:b;
}

模板实例化时

Max(2,2.4)

参数推导会出现模板实参类型 int 与 double 不一致的错误。
解决方法：

每个模板参数独立类型

template <typename T , typename U> inline const T& Max(const T& a, const U& b){
        return a>b?a:b;
}

注意：这种解决方法还有一个问题，就是返回值只能强制设置为 T 或者 U，不能自动推导。C++11 的后置推导解决这个问题。

template <typename T, typename U> 
inline auto Max(const T& a, const U& b)->decltype(a>b?a:b)
{
        return a>b?a:b;
}

显示指定模板实参类型

Max<int>(2,2.4)

或者

Max<double>(2,2.4)

实参强制类型转换

Max(2,static_cast<int>(2.4))

或者

Max(static_cast<double>(2),2.4)

模板参数推导不允许类型自动转换，模板参数必须严格匹配。

函数模板实例显示指定模板实参可以显示指定模板实参，也可以不指定(类型自动推导)，类模板实例化必须指定

实例

#include <iostream>
#include <cstring> // strcmp()
using namespace std;

template<typename T,int n>
void Show(T m){
    if(n==1){
        cout << oct << m << endl;
    }else if(n==2){
        cout << dec << m << endl;
    }else {
        cout << hex << m << endl;
    }
}
/*
void PrintArr(int* arr,int n){
    for(int i=0;i<n;++i){
        cout << arr[i] << " ";
    }
    cout << endl;
}*/
template<typename T>
void PrintArr(T* arr,int n){
    for(int i=0;i<n;++i){
        cout << arr[i] << " ";
    }
    cout << endl;
}
/*
template<typename T,int n>
void PrintArr(T* arr){
    for(int i=0;i<n;++i){
        cout << arr[i] << " ";
    }
    cout << endl;
}
*/
template<typename T,int n>
void PrintArr(T (&arr)[n]){
    for(int i=0;i<n;++i){
        cout << arr[i] << " ";
    }
    cout << endl;
}
// 把模板类型分开
/*
template<typename T,typename U>
T Max(T a,U b){
    return a>b?a:b;
}*/
template<typename T>
const T& Max(const T& a,const T& b){
    return a>b?a:b;
}
// 特化成指针类型
template<typename T>
    const T* Max(const T* a,const T* b){
    return *a > *b?a:b;
}
// 特化成字符数组
template<>
const char* Max(const char* a,const char* b){
    return strcmp(a,b)>0?a:b;
}

int main(){
    // 指定类型
    cout << Max<int>(10,13) << endl;
    cout << Max<float>(10.01F,10.1F) << endl;
    cout << Max<double>(10.01,10.1) << endl;
    cout << Max<string>(string("abc"),string("def"))<< endl; // 可以不可以使用const string&?
    cout << Max<string>("abc","def")<< endl;

    // 自动推导
    cout << Max(10,13) << endl; // Max<int>()
    cout << Max(10.01F,10.1F) << endl; // Max<float>()
    cout << Max(10.01,10.1) << endl; // Max<double>()
    cout << Max(string("abc"),string("def"))<< endl; // Max<string>()
    cout << Max("abc","def")<< endl; // 为什么结果不正确？ // Max<char*>()
    // 不能自动推导的情况
    cout << Max((double)10,13.1) << endl; // 强制类型转换，保证类型一致
    cout << Max<double>(10,13.1) << endl; // 显示实例化
   
    int a = 25;
    int b = 20;

    cout << *Max(&a,&b) << endl; // Max<int>(int*,int*)

    const char* str = "abcd";
    cout << *Max(str,str+1) << endl; // Max<char>(char*,char*)

    // 非类类型模板参数，使用的时候非类类型模板参数必须使用常量赋值，不能使用变量。
    Show<int,1>(100);
    Show<int,2>(100);
    Show<int,3>(100);
    // int n = 1;
    // Show<int,n>(100);
    {
    int arr[] = {1,2,3,4,5};
    //PrintArr(arr,sizeof(arr)/sizeof(arr[0]));
    // PrintArr<int,sizeof(arr)/sizeof(arr[0])>(arr);
    PrintArr(arr);
    }
    {
    float arr[] = {1.1,2.2,3.3,4.4,5.5};
    PrintArr(arr);
    }
}

5. 特化

模板特化(specialization):模板参数在某种特定类型下的具体实现称为模板的特化。模板特化有时也称之为模板的具体化。

特化作用

对于某种特殊类型，可以做特殊处理或者优化。
避免实例化类的时候产生诡异行为。

模板特化分类

函数模板特化(Function specializations)：对函数模板的全部模板类型指定具体类型。
类模板特化(Class specializations)：对类模板的全部或者部分模板类型指定具体类型。

5.1 函数模板特化

特点：函数模板，却只有全特化，不能偏特化。
步骤：与类的全特化相同

示例：

template<typename T>
void Func(const T& n){}

// 特化
template<>
void Func(const int& n){}

5.2 类模板特化

特点：类模板特化，每个成员函数必须重新定义。

类模板特化分为两种

全特化(Full specializations)：具体指定模板的全部模板参数的类型。
局部特化(Partial specializations)：具体指定模板的部分模板参数的类型。

实例：三元组模版Triple

类模板特化，相当于函数模板的重载

全特化和偏特化的编码区别：
全特化的模板参数列表为空 template<>，偏特化的模板参数列表不为空。

#include <iostream>
using namespace std;

template<typename T, typename S, typename U>
class Triple{
    T t;
    S s;
    U u;
public:
    Triple(T t,S s, U u):t(t),s(s),u(u){}
    T& First(){return t;}
    S& Second(){return s;}
    U& Third(){return u;}
};

int main()
{
    Triple<string,bool,int> st("ahtl",1,27);
    cout << st.First() <<" " <<st.Second()<<" " << st.Third()<< endl;
    return 0;
}

5.2.1 全特化

步骤：

声明一个模板空参数列表 template<>
在类名称后面的 <> 中显示指定类型。

示例：

// 模板  
template<class T>
class Test{};

// 全特化
template<>
class Test<int*>{};

(1)类的全特化的写法

template<>
class Triple<string,bool,int>{
    string t;
    bool s;
    int u;
public:
    Triple(string t,bool s, int u):t(t),s(s),u(u){
    cout << "Template:specificition" <<endl;
    }
    string& First(){return t;}
    bool& Second(){return s;}
    int& Third(){return u;}

};

完整案例

#include <iostream>
using namespace std;

template<typename T, typename S, typename U>
class Triple{
    T t;
    S s;
    U u;
public:
    Triple(T t,S s, U u):t(t),s(s),u(u){}
    T& First(){return t;}
    S& Second(){return s;}
    U& Third(){return u;}
};

template<>
class Triple<string,bool,int>{
    string t;
    bool s;
    int u;
public:
     Triple(string t,bool s, int u):t(t),s(s),u(u){
     cout << "Template:specificition" <<endl;
     }
    string& First(){return t;}
    bool& Second(){return s;}
    int& Third(){return u;}

};

int main()
{
    Triple<string,bool,int> st("ahtl",1,27);
    cout << st.First() <<" " <<st.Second()<<" " << st.Third()<< endl;
    return 0;
}

5.2.2 偏特化

偏特化就是部分特化，分为两种情况

个数特化：只为部分模板参数指定具体类型(模板参数个数变少)
范围特化：模板参数不变，限制模板参数的匹配类型(指针、引用、const)

步骤：

在一个模板类参数列表不指定或者指定部分具体类型。
在类名称后面的对应类型中显示指定该类型。

示例：

template<typename T1,typename T2>
class Test{};

将模板参数偏特化为相同类型

template<typename T>
class Test<T,T>{};

将一个模板参数特化成具体类型

template<typename T>
class Test<T,int>{};

把两个类型偏特化成指针类型

template<typename T1,typename T2>
class Test<T1*,T2*>{};

注意：
（1）优先级顺序：全 > 偏 > 元祖
（2）偏特化：参数特化为某几个
（3）引用的时候：const 很重要

#include <iostream>
using namespace std;

//（1）优先级顺序：全 > 偏 > 元祖
//（2）偏特化：参数特化为某几个
//（3）const的重要性

//1.最初的模板

template<typename T, typename S, typename U>
class Triple{
    T t;
    S s;
    U u;
public:
    Triple(T t,S s, U u):t(t),s(s),u(u){}
    T& First(){return t;}
    S& Second(){return s;}
    U& Third(){return u;}
};
//2.全特化
template<>
class Triple<string,bool,int>{
    string t;
    bool s;
    int u;
public:
     Triple(string t,bool s, int u):t(t),s(s),u(u){
     cout << "Template::all specificition" <<endl;
     }
    string& First(){return t;}
    bool& Second(){return s;}
    int& Third(){return u;}

};



//3.全特化为引用类型
template<typename T, typename S, typename U>
class Triple<const T&,const S&, const U&>{ // 元组：里面的元素类型可以不同/ 数组：里面的元素类型必须相同
    const T& t;
    const S& s;
    const U& u;
public:
    Triple(const T& t,const S& s, const U& u):t(t),s(s),u(u){ cout << "Template::all specificition(&)" <<endl;}
    const T& First(){return t;}
    const S& Second(){return s;}
    const U& Third(){return u;}
};



//4.偏特化
template<typename S, typename U>
class Triple<string,S,U>{
    string t;
    S s;
    U u;
public:
     Triple(string t,S s, U u):t(t),s(s),u(u){
     cout << "Template::SIDE specificition" <<endl;
     }
    string& First(){return t;}
    S& Second(){return s;}
    U& Third(){return u;}

};

class Test{};

int main()
{
    Triple<string,bool,int> st("johnsonlee",1,27);
    const Test t;
    Triple<const Test&,const Test&,const Test&> st2(t,t,t);
    cout << st.First() <<" " <<st.Second()<<" " << st.Third()<< endl;
    return 0;
}

模板原理

在这里插入图片描述

模板通常会被编译两次

实例化前，检查模板代码是否有语法错误。
实例化中，检查模板代码调用是否合法。

非类型模版参数

非类型模板的实参只能是整型常量、枚举值或者指向外部链接对象的指针。
不能使用浮点型、类对象、内部链接对象的指针。

技巧

函数模板参数尽量使用引用类型 const &（可以省略一次拷贝构造）
例如：

template <typename T> inline const T& Max(const T& a, const T& b){
        return a>b?a:b;
}

类模板

成员函数：只有调用时才会被实例化。
静态成员：每次类模板实例化，都会被实例化。

类实例化成对象，类模板实例化成类。

类模板：不完整的类，一个或者多个成员类型未确定。
函数模板：不完整的函数，一个或者多个参数类型未确定。

实例

函数模板重载和特化

#include <iostream>
#include <cstring>
using namespace std;

// 引用类型模板
template <typename T>
bool Equal(const T& a,const T& b){
    return a == b;
}

// 特化成浮点型
template<>
bool Equal(const double& a,const double& b){
    return abs(a-b) < 1e-6;
}

// -------------------------------------------------
// 指针类型模板(函数模板重载)
template<typename T>
bool Equal(const T* a,const T* b){
    return *a==*b;
}

// 特化成char*
template<>
bool Equal(const char* a,const char* b){
    return strcmp(a,b)==0;
}

int main(){
    cout << Equal(1,1) << endl;
    cout << Equal(1.2,1.2) << endl;
    cout << Equal(string("abc"),string("abc")) << endl;


    cout << Equal(1,2) << endl;
    cout << Equal(1.2,1.21) << endl;
    cout << Equal(string("abcd"),string("abc")) << endl;
    
    cout << Equal(1.2,(10.2-9)) << endl;


    int arr[] = {1,2,3,1};
    cout << Equal(arr,arr+3) << endl; // bool Equal(int*,int*)

    cout << Equal("abc","abcd") << endl;
}