C++ 泛型编程 模板

1.模板

就是建立通用的模具，大大提高复用性

模板的特点：

  • 模板不可以直接使用，它只是一个框架

  • 模板的通用并不是万能的

* C++另一种编程思想称为 ==泛型编程== ，主要利用的技术就是模板


* C++提供两种模板机制:**函数模板**和**类模板**

2函数模板

函数模板作用：

建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表。

语法：

template<typename T>
函数声明或定义

template  ---  声明创建模板

typename  --- 表面其后面的符号是一种数据类型，可以用class代替

T    ---   通用的数据类型，名称可以替换，通常为大写字母

//交换整型函数
void swapInt(int& a, int& b) {int temp = a;a = b;b = temp;
}
//交换浮点型函数
void swapDouble(double& a, double& b) {double temp = a;a = b;b = temp;
}
//利用模板提供通用的交换函数
template<typename T>
void mySwap(T& a, T& b)
{T temp = a;a = b;b = temp;
}
void test01()
{int a = 10;int b = 20;//swapInt(a, b);//利用模板实现交换//1、自动类型推导mySwap(a, b);//2、显示指定类型
//    mySwap<int>(a, b);cout << "a = " << a << endl;cout << "b = " << b << endl;
}

总结：

* 函数模板利用关键字 template
* 使用函数模板有两种方式：自动类型推导、显示指定类型
* 模板的目的是为了提高复用性，将类型参数化

注意事项：

* 自动类型推导，必须推导出一致的数据类型T,才可以使用
* 模板必须要确定出T的数据类型，才可以使用

//利用模板提供通用的交换函数
template<class T>
void mySwap(T& a, T& b)
{T temp = a;a = b;b = temp;
}
// 1、自动类型推导，必须推导出一致的数据类型T,才可以使用
void test01()
{int a = 10;int b = 20;char c = 'c';mySwap(a, b); // 正确，可以推导出一致的T//mySwap(a, c); // 错误，推导不出一致的T类型
}
// 2、模板必须要确定出T的数据类型，才可以使用
template<class T>
void func()
{cout << "func 调用" << endl;
}
void test02()
{//func(); //错误，模板不能独立使用，必须确定出T的类型func<double>(); //利用显示指定类型的方式，给T一个类型，才可以使用该模板
}

 3.普通函数和函数模版的区别

* 普通函数调用时可以发生自动类型转换（隐式类型转换）
* 函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
* 如果利用显示指定类型的方式，可以发生隐式类型转换

#include<iostream>
#include<fstream>
#include<string>
using namespace std;
//普通函数
int myAdd01(int a, int b)
{return a + b;
}
//函数模板
template<class T>
T myAdd02(T a, T b)
{return a + b;
}
//使用函数模板时，如果用自动类型推导，不会发生自动类型转换,即隐式类型转换
void test01()
{int a = 10;int b = 20;char c = 'c';cout << myAdd01(a, c) << endl; //正确，将char类型的'c'隐式转换为int类型  'c' 对应 ASCII码 99//myAdd02(a, c); // 报错，使用自动类型推导时，不会发生隐式类型转换myAdd02<int>(a, c); //正确，如果用显示指定类型，可以发生隐式类型转换
}
int main() {test01();return 0;
}

4.普通函数和函数模板的调用规则

调用规则如下：

1. 如果函数模板和普通函数都可以实现，优先调用普通函数
2. 可以通过空模板参数列表来强制调用函数模板
3. 函数模板也可以发生重载
4. 如果函数模板可以产生更好的匹配,优先调用函数模板

//普通函数与函数模板调用规则
void myPrint(int a, int b)
{cout << "调用的普通函数" << endl;
}template<typename T>
void myPrint(T a, T b) 
{ cout << "调用的模板" << endl;
}template<typename T>
void myPrint(T a, T b, T c) 
{ cout << "调用重载的模板" << endl; 
}void test01()
{//1、如果函数模板和普通函数都可以实现，优先调用普通函数// 注意 如果告诉编译器  普通函数是有的，但只是声明没有实现，或者不在当前文件内实现，就会报错找不到int a = 10;int b = 20;myPrint(a, b); //调用普通函数//2、可以通过空模板参数列表来强制调用函数模板myPrint<>(a, b); //调用函数模板//3、函数模板也可以发生重载int c = 30;myPrint(a, b, c); //调用重载的函数模板//4、 如果函数模板可以产生更好的匹配,优先调用函数模板char c1 = 'a';char c2 = 'b';myPrint(c1, c2); //调用函数模板
}int main() {test01();system("pause");return 0;
}

总结：既然提供了函数模板，最好就不要提供普通函数，否则容易出现二义性

5.函数模版的局限性

**例如：**

```C++
    template<class T>
    void f(T a, T b)
    {
        a = b;
    }
```

在上述代码中提供的赋值操作，如果传入的a和b是一个数组，就无法实现了

再例如：

```C++
    template<class T>
    void f(T a, T b)
    {
        if(a > b) { ... }
    }
```

在上述代码中，如果T的数据类型传入的是像Person这样的自定义数据类型，也无法正常运行

因此C++为了解决这种问题，提供模板的重载，可以为这些**特定的类型**提供**具体化的模板**

 

#include<iostream>
using namespace std;
#include <string>
class Person
{
public:Person(string name, int age){this->m_Name = name;this->m_Age = age;}string m_Name;int m_Age;
};
//普通函数模板
template<class T>
bool myCompare(T& a, T& b)
{if (a == b){return true;}else{return false;}
}
//具体化，显示具体函数模板以template<>开头，并通过名称来指出类型
//具体化优先于常规模板
template<> bool myCompare(Person &p1, Person &p2)
{if ( p1.m_Name  == p2.m_Name && p1.m_Age == p2.m_Age){return true;}else{return false;}
}
void test01()
{int a = 10;int b = 20;//内置数据类型可以直接使用通用的函数模板bool ret = myCompare(a, b);if (ret){cout << "a == b " << endl;}else{cout << "a != b " << endl;}
}void test02()
{Person p1("Tom", 10);Person p2("Tom", 10);//自定义数据类型，不会调用普通的函数模板//可以创建具体化的Person数据类型的模板，用于特殊处理这个类型bool ret = myCompare(p1, p2);if (ret){cout << "p1 == p2 " << endl;}else{cout << "p1 != p2 " << endl;}
}int main() {test01();test02();return 0;
}

  • 利用具体化的模板，可以解决自定义类型的通用化

  • 学习模板并不是为了写模板，而是在STL能够运用系统提供的模板

6.类模板

类模板作用：

* 建立一个通用类，类中的成员 数据类型可以不具体制定，用一个**虚拟的类型**来代表

语法：

template<typename T>
类

template  ---  声明创建模板

typename  --- 表面其后面的符号是一种数据类型，可以用class代替

T    ---   通用的数据类型，名称可以替换，通常为大写字母

#include<iostream>
using namespace std;
#include <string>
// 类模板
template<class NameType,class AgeType>
class Person{
public:Person(NameType name,AgeType age){this->m_Name = name;this->m_Age = age;}void showPerson(){cout<<"name:"<<this->m_Name<<" age:"<<this->m_Age<<endl;}NameType m_Name;AgeType m_Age;
};int main() {
//    指定Nametype为int，Agetype为stringPerson<int,string> p1(10,"Tom");p1.showPerson();return 0;
}

总结：类模板和函数模板语法相似，在声明模板template后面加类，此类称为类模板

类模板与函数模板区别

类模板与函数模板区别主要有两点：

1. 类模板没有自动类型推导的使用方式
2. 类模板在模板参数列表中可以有默认参数

//类模板
template<class NameType, class AgeType = int> //1、类模板没有自动类型推导的使用方式
void test01()
{// Person p("孙悟空", 1000); // 错误 类模板使用时候，不可以用自动类型推导Person <string ,int>p("孙悟空", 1000); //必须使用显示指定类型的方式，使用类模板p.showPerson();
}//2、类模板在模板参数列表中可以有默认参数
void test02()
{Person <string> p("猪八戒", 999); //类模板中的模板参数列表 可以指定默认参数p.showPerson();
}

但是我发现，这东西就像占位参数一样，只要有一个默认参数，之后所有的参数都必须有默认参数。

#include<iostream>
using namespace std;
#include <string>
// 类模板 
template<class AgeType =int,class NameType=string >
class Person{
public:Person(NameType name,AgeType age){this->m_Name = name;this->m_Age = age;}void showPerson(){cout<<"name:"<<this->m_Name<<" age:"<<this->m_Age<<endl;}NameType m_Name;AgeType m_Age;
};int main() {
//    指定Nametype为int，Agetype为stringPerson p1("Tom",20);p1.showPerson();return 0;
}

类模板中成员函数创建时机

类模板中成员函数和普通类中成员函数创建时机是有区别的：

* 普通类中的成员函数一开始就可以创建
* 类模板中的成员函数在调用时才创建

#include<iostream>
using namespace std;
#include <string>
class Person1{
public:void showPerson1(){cout << "Person1 show" << endl;}
};
class Person2{
public:void showPerson2(){cout << "Person2 show" << endl;}
};
template<class T>
class MyClass{
public:T obj;
//    类模板中的成员函数并不是一开始就创建的，而是在调用的时候才去创建的。void fun1(){obj.showPerson1();}void fun2(){obj.showPerson2();}
};
int main() {MyClass<Person1> m;m.fun1();
//    m.fun2();  编译会报错了，说明函数调用才会去创建成员函数。return 0;
}

类模板对象做函数参数

一共有三种传入方式：

1. 指定传入的类型   --- 直接显示对象的数据类型
2. 参数模板化           --- 将对象中的参数变为模板进行传递
3. 整个类模板化       --- 将这个对象类型 模板化进行传递

#include<iostream>
using namespace std;
#include <string>
//类模板
template<class NameType,class AgeType=int>
class Person{
public:Person(NameType name,AgeType age){this->m_Name = name;this->m_Age = age;}void showPerson(){cout<<"name:"<<this->m_Name<<" age:"<<this->m_Age<<endl;}NameType m_Name;AgeType m_Age;
};
// 1.指定传入类型
void printPerson1(Person<string,int> &p){p.showPerson();
}
//2.参数模板化
template<class T1,class T2>
void printPerson2(Person<T1,T2> &p){p.showPerson();cout<<"T1的类型为："<<typeid(T1).name()<<endl;cout<<"T2的类型为："<<typeid(T2).name()<<endl;
}
//3.整个类模板化
template<class T>
void printPerson3(T &p){p.showPerson();cout<<"T的类型为："<<typeid(T).name()<<endl;
}
int main() {Person<string,int> p1("Tom",20);printPerson1(p1);Person<string,int> p2("Jerry",30);printPerson2(p2);Person<string,int> p3("David",40);printPerson3(p3);return 0;
}

类模板与继承

当类模板碰到继承时，需要注意一下几点：

* 当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型
* 如果不指定，编译器无法给子类分配内存
* 如果想灵活指定出父类中T的类型，子类也需变为类模板

#include<iostream>
using namespace std;
#include <string>
template<class T>
class Base{T m;
};
//  子类继承类模板，必须为父类模板指定类型，否则编译器无法给子类分配内存
class Son :public Base<int>{};
// 类模板继承类模板，可以用T1或T2指定父类模板的类型
template<class T1,class T2>
class Son2:public Base<T1>{
public:Son2(){cout<<"T1的类型为："<<typeid(T1).name()<<endl;cout<<"T2的类型为："<<typeid(T2).name()<<endl;}
};
int main() {Son c;Son2<int,string> c2;return 0;
}

如果父类是类模板，子类需要指定出父类中T的数据类型

类模板成员函数类外实现

#include<iostream>
using namespace std;
#include <string>
template<class T1,class T2>
class Person{
public:
//    成员函数类内声明Person(T1 name,T2 age);void showPerson();T1 m_Name;T2 m_Age;
};
// 类外实现
template<class T1,class T2>
Person<T1,T2>::Person(T1 name,T2 age){this->m_Name = name;this->m_Age = age;
}
// 类外实现
template<class T1,class T2>
void Person<T1,T2>::showPerson(){cout<<"name:"<<this->m_Name<<" age:"<<this->m_Age<<endl;
}
int main() {Person<string,int> p("Tom",20);p.showPerson();return 0;
}

总结：类模板中成员函数类外实现时，需要加上模板参数列表

类模板分文件编写

回顾分文件编写

.h文件写声明

.cpp 文件写实现

#pragma once   #防止头文件重复包含

类模板中成员函数创建时机是在调用阶段，导致分文件编写时链接不到。

所以按照之前的写法会报错

解决办法：

1.在main.cpp主函数中引入Person.cpp,而不是.h文件

2.将声明和实现写到同一个文件中，并更改后缀名为.hpp，hpp是约定的名称，并不是强制

#pragma once
#include <iostream>
using namespace std;
#include <string>template<class T1, class T2>
class Person {
public:Person(T1 name, T2 age);void showPerson();
public:T1 m_Name;T2 m_Age;
};//构造函数 类外实现
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age) {this->m_Name = name;this->m_Age = age;
}//成员函数 类外实现
template<class T1, class T2>
void Person<T1, T2>::showPerson() {cout << "姓名: " << this->m_Name << " 年龄:" << this->m_Age << endl;
}
#include<iostream>
using namespace std;//#include "person.h"
#include "person.cpp" //解决方式1，包含cpp源文件//解决方式2，将声明和实现写到一起，文件后缀名改为.hpp
#include "person.hpp"
void test01()
{Person<string, int> p("Tom", 10);p.showPerson();
}int main() {test01();system("pause");return 0;
}

总结：主流的解决方式是第二种，将类模板成员函数写到一起，并将后缀名改为.hpp

类模板与友元

全局函数类内实现 - 直接在类内声明友元即可

全局函数类外实现 - 需要提前让编译器知道全局函数的存在

#include<iostream>
using namespace std;
#include <string>//***********************************************
//  全局函数类外实现
template<class T1,class T2>
class Person;
template<class T1,class T2>
void printPerson2(Person<T1,T2> p){cout<<p.m_Name<<" 类外实现 "<<p.m_Age<<endl;
}
//***********************************************template<class T1,class T2>
class Person{
//  1.全局函数配合友元 类内实现friend void printPerson(Person<T1,T2> p){cout<<p.m_Name<<" "<<p.m_Age<<endl;}
//    2.全局函数配合友元 类外实现friend void printPerson2<>(Person<T1,T2> p);
public:Person(T1 name,T2 age){this->m_Name = name;this->m_Age = age;}
private:T1 m_Name;T2 m_Age;
};
int main() {Person<string,int> p("Tom",20);printPerson2(p);return 0;
}

总结：建议全局函数做类内实现，用法简单，而且编译器可以直接识别

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/816383.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

快速配置docker 国内源地址

快速配置docker 国内源地址

前言 用于快速配置docker国内镜像&#xff0c;和自定义的docker存储路径。 执行代码 sudo mkdir -p /etc/docker sudo tee /etc/docker/daemon.json <<-EOF {"registry-mirrors": ["https://dockerproxy.com","https://docker.mirrors.ustc.…
阅读更多...
webrtc中的Track,MediaChannel,MediaStream

webrtc中的Track,MediaChannel,MediaStream

文章目录 Track,MediaChannel,MediaStream的关系MediaStream的创建流程创建VideoChannel的堆栈创建VideoStream的堆栈 sdp中媒体参数信息的映射sdp中媒体信息参数设置体系参数设置流程参数映射体系 Track,MediaChannel,MediaStream的关系 Audio/Video track&#xff0c;MediaC…
阅读更多...
[每周一更]-第93期：探索大型生成式聊天工具：从ChatGPT到未来

[每周一更]-第93期：探索大型生成式聊天工具：从ChatGPT到未来

随着人工智能技术的不断进步&#xff0c;生成式聊天工具正逐渐成为人们日常生活中的一部分。这些工具利用深度学习技术和大规模语言模型的强大能力&#xff0c;能够与用户进行自然、流畅的对话&#xff0c;为我们提供了更加智能和个性化的交流体验。 ChatGPT&#xff1a;开启生…
阅读更多...
[前端][杂项] React版本

[前端][杂项] React版本

前言 前端框架版本迭代很快&#xff0c;所以熟悉框架的版本也很重要。 React 版本介绍 。github上有更加详细的文档 React历史版本下载 因为 React 使用的是 jsx 如果要在浏览器环境中使用 jsx 那么还需要使用babel.js把jsx转换成原生js文件才能被浏览器使用。 babel官网 babe…
阅读更多...
基于RT-Thread(RTT)的BMP280气压计驱动（I2C通信）

基于RT-Thread(RTT)的BMP280气压计驱动（I2C通信）

前言 本文基于RTT操作系统使用STM32F401RET6驱动BMP280气压计模块&#xff0c;使用I2C协议通信 一、新建工程 二、添加软件包 三、添加这个包 四、打开CubeMX 五、配置时钟源&#xff0c;使用外部晶振 六、配置串行下载口 七、打开I2C&#xff0c;我这里使用的是I2C2&#x…
阅读更多...
LabVIEW直流稳定电源自动化校准系统

LabVIEW直流稳定电源自动化校准系统

LabVIEW直流稳定电源自动化校准系统 直流稳定电源正向着智能化、高精度、多通道、宽量程的方向发展。基于LabVIEW开发环境&#xff0c;设计并实现了一种直流稳定电源自动化校准系统&#xff0c;以提升校准过程的整体效能&#xff0c;实现自动化设备替代人工进行电源校准工作。…
阅读更多...
【opencv】示例-stiching.cpp 图像拼接

【opencv】示例-stiching.cpp 图像拼接

#include "opencv2/imgcodecs.hpp" // 导入opencv图像编码功能库 #include "opencv2/highgui.hpp" // 导入opencv高层用户界面功能库 #include "opencv2/stitching.hpp" // 导入opencv图像拼接功能库#include <iostream> // 导入输入输出…
阅读更多...
PyQt5

PyQt5

Qt是基于C实现的GUI,而PyQt就是用python调用Qt. PyQt中有很多的功能模块,开发最常用的模块功能主要有3个 1) QtCore:包含核心的非GHI的功能,主要和时间,文件与文件夹,各种数据,流,URLs,进程与线程一起使用 2) QtGUi:包含窗口系统,事件处理,2D图像,基本绘画,字体和文字类 3)…
阅读更多...
详解构造函数

详解构造函数

前言 希望这篇文章是有意义的&#xff0c;能够帮助初学者理清构造函数的概念&#xff0c;关系及误区。首先定义一个日期类&#xff0c;借助日期类讲解构造函数。 class Date {public:void Init(int year, int month, int day) //初始化数据的方法{_year year;_month month…
阅读更多...
Ubuntu快捷安装MySQL

Ubuntu快捷安装MySQL

更新包列表 sudo apt update 安装mysql sudo apt install mysql-server 启动mysql // 启动mysql sudo service mysql start// 关闭mysql sudo service mysql stop// 重启mysql sudo service mysql restart 连接mysql // 初始安装无密码&#xff0c;直接连接即可&#xf…
阅读更多...
hive metastore使用mysql作为backend db遇到的问题

hive metastore使用mysql作为backend db遇到的问题

文章目录 问题解决 问题 hms使用mysql作为Backend metadata database, 但是启动爆如下错误. Underlying cause: com.mysql.cj.jdbc.exceptions.CommunicationsException : Communications link failureThe last packet sent successfully to the server was 0 milliseconds a…
阅读更多...
[MAC] mac电脑更新 git的安装homebrew

[MAC] mac电脑更新 git的安装homebrew

官方网站需要翻墙&#xff0c;不能下载。试了网上好几种方法&#xff0c;以下方法完胜。 1、国内镜像进行下载的homebrew,一步到位 mac电脑打开终端输入: /bin/zsh -c "$(curl -fsSL https://gitee.com/cunkai/HomebrewCN/raw/master/Homebrew.sh)" 2、查看 原有g…
阅读更多...
【opencv】示例-train_HOG.cpp 训练和测试基于支持向量机(SVM)的行人检测器

【opencv】示例-train_HOG.cpp 训练和测试基于支持向量机(SVM)的行人检测器

#include "opencv2/imgproc.hpp" // 包含OpenCV图像处理头文件 #include "opencv2/highgui.hpp" // 包含OpenCV高层GUI&#xff08;图形用户界面&#xff09;头文件 #include "opencv2/ml.hpp" // 包含OpenCV机器学习模块头文件 #includ…
阅读更多...
typora支持的流程图的语法

typora支持的流程图的语法

流程图 typora支持以下代码块画流程图 flow&#xff1a;流程图&#xff0c;会自动被 flowchart.js 渲染。sequence&#xff1a;序列图&#xff0c;会自动被 js-sequence 解析和渲染mermaid&#xff1a;mermaid图。 要使 Typora 支持代码绘图&#xff0c;需要对 Typora 软件进…
阅读更多...
数据结构初阶：二叉树（二）

数据结构初阶：二叉树（二）

二叉树链式结构的实现 前置说明 在学习二叉树的基本操作前&#xff0c;需先要创建一棵二叉树&#xff0c;然后才能学习其相关的基本操作。由于现在对二叉树结构掌握还不够深入&#xff0c;为了降低学习成本&#xff0c;此处手动快速创建一棵简单的二叉树&#xff0c;快速进入二…
阅读更多...
设计模式之工厂模式(python3)

设计模式之工厂模式(python3)

一、简单工厂模式 什么是简单工厂模式&#xff1f; 专门定义一个类来负责创建其他类的实例&#xff0c;根据参数的不同创建不同类的实例&#xff0c;被创建的实例通常具有共同的父类&#xff0c;这个模式叫简单工厂模式&#xff08;Simple Factory Pattern&#xff09;。 &qu…
阅读更多...
二、Flask会话技术和模板语言

二、Flask会话技术和模板语言

Cookie Session # views.py: 路由 视图函数 import datetimefrom flask import Blueprint, render_template, request, redirect, session from .models import *# 蓝图 blue Blueprint(user, __name__)# 首页 可以写两个路由&#xff0c;都是访问同一个函数 blue.route(/) b…
阅读更多...
【数据结构】泛型（分享重点）

【数据结构】泛型（分享重点）

什么是泛型&#xff1f; 泛型就是适用于许多许多类型&#xff0c;对类型参数化。 怎么创建一个泛型呢 class 泛型类名称<类型形参列表> { // 这里可以使用类型参数 } class ClassName<T1, T2, ..., Tn> { } class 泛型类名称<类型形参列表> extends 继承类…
阅读更多...
微服务之LoadBalancer负载均衡服务调用

微服务之LoadBalancer负载均衡服务调用

一、概述 1.1什么是负载均衡 LB&#xff0c;既负载均衡&#xff08;Load Balancer&#xff09;,是高并发、高可用系统必不可少的关键组件&#xff0c;其目标是尽力将网络流量平均分发到多个服务器上&#xff0c;以提高系统整体的响应速度和可用性。 负载均衡的主要作用 高并发…
阅读更多...
回归预测 | Matlab基于RIME-SVR霜冰算法优化支持向量机的数据多输入单输出回归预测

回归预测 | Matlab基于RIME-SVR霜冰算法优化支持向量机的数据多输入单输出回归预测

回归预测 | Matlab基于RIME-SVR霜冰算法优化支持向量机的数据多输入单输出回归预测 目录 回归预测 | Matlab基于RIME-SVR霜冰算法优化支持向量机的数据多输入单输出回归预测预测效果基本描述程序设计参考资料 预测效果 基本描述 1.Matlab基于RIME-SVR霜冰算法优化支持向量机的数…
阅读更多...
最新文章

Copyright @ 2022~2023