C++之泛型编程

最新推荐文章于 2024-03-10 21:58:54 发布
最新推荐文章于 2024-03-10 21:58:54 发布
阅读量1.8k 收藏 10
点赞数 2
分类专栏： C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60027772/article/details/128172671
版权

目录

模板

模板的特点

函数模板

前言

函数模板的使用方式

函数模板具体案例

使用模板的注意事项

普通函数与函数模板间的区别

具体案例

普通函数与函数模板调用规则

模板的局限性

具体化模板

类模板

前言

类模板与函数模板的区别

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

类模板对象做函数的参数

传入方式

具体案例

类模板与继承

前言

子类指定具体类型案例

子类不指定具体类型案例

类模板成员函数的类外实现

类模板分文件编写

1.直接包含源文件

2.将.h和.cpp文件中的内容写到一起，后将后缀名改为.hpp文件

类模板与友元

模板

前言：

  • C++中相对于面向对象的另一种编程思想就是泛型编程，主要利用的技术就是模板
  • C++提供了两种模板机制（函数模板和类模板）

概念：模板就是建立通用的模具，大大提高复用性

模板的特点

  • 模板不可以直接使用，它只是一个框架
  • 模板通用性很强，但是并不是万能的

使用模板的目的：提高复用性，将类型参数化 

函数模板

前言

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

语法：

//声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用的数据类型
template<typename T>
函数声明或函数定义

解释：

  • template：声明创建模板
  • typename：表明其后面的符号为一种数据类型（该关键字也可以用class代替）
  • T：通用的数据类型；名称可以替换，通常为大写字母。

函数模板的使用方式

  • 自动类型推导：向交换模板函数中传递的参数的类型会被自动解析
  • 显示指定类型：指定模板的具体数据类型

函数模板具体案例

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;
//函数模板
template <typename T>
//通用交换函数模板
void mySwap(T& a, T& b) {
	T temp = a;
	a = b;
	b = temp;
}
void main() {
	int a = 10;
	int b = 20.0;
	//自动类型推导（a和b的数据类型会被自动解析）
	mySwap(a, b);
	cout << "a:" << a << "\tb:" << b << endl;
	//显式指定类型（<int>为模板参数）
	mySwap<int>(a,b);
	cout << "a:" << a << "\tb:" << b << endl;
}

使用模板的注意事项

  • 在函数中，若多个参数使用模板，那么自动类型推导必须推导出一致的数据类型才可以使用
  • 模板必须确定出T的数据类型才可以使用

普通函数与函数模板间的区别

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

具体案例

#include <iostream>
using namespace std;
template <typename T>
T myAdd(T a, T b) {
	return a + b;
}
void main() {
	int a = 10;
	char c = 'c';
	//自动类型推导
	//cout << myAdd(a, c) << endl;//报错，参数类型的指定必须一致，不能自动类型转换
	//隐式指定类型
	cout << myAdd<int>(a, c) << endl;
	//明确说明T的类型为int，传入的参数是int类型直接传，不是int类型则使用隐式类型转换转为int类型
}

普通函数与函数模板调用规则

1.若函数模板与普通函数都可以调用，则优先调用普通函数

void myPrint(int a, int b) {
	cout << "调用普通函数" << endl;
}
template <typename T>
void myPrint(T a, T b) {
	cout << "调用函数模板" << endl;
}
void main() {
	int a = 10;
	int b = 20;
	myPrint(a, b);//调用普通函数
}

2.可以通过空模板参数列表的方式来强制调用函数模板

//只写了函数声明，没写函数实现
void myPrint(int a, int b);
template <typename T>
void myPrint(T a, T b) {
	cout << "调用函数模板" << endl;
}
void main() {
	int a = 10;
	int b = 20;
	//通过空模板的参数列表强制调用函数模板
	myPrint<>(a, b);
}

3.模板也可以实现函数重载

template <typename T>
void myPrint(T a, T b) {
	cout << "调用函数模板1" << endl;
}
//重载函数模板
template <typename T>
void myPrint(T a, T b, T c) {
	cout << "调用函数模板2" << endl;
}
void main() {
	int a = 10;
	int b = 20;
	int c = 30;
	//调用函数模板1
	myPrint(a, b);
	//调用函数模板2
	myPrint(a, b, c);
}

4.如果函数模板可以产生更好的匹配，则优先使用函数模板

void myPrint(int a, int b) {
	cout << "调用普通函数" << endl;
}
template <typename T>
void myPrint(T a, T b) {
	cout << "调用函数模板" << endl;
}
void main() {
	char a = 'a';
	char b = 'b';
	//调用函数模板
	myPrint(a, b);
}

注意：若提供了函数模板，那么最好就不要提供普通函数，否则容易出现二义性

模板的局限性

template <class T>
void func(T a, T b) {
	a = b;
}

注意：模板并不是万能的，该模板函数有一个局限性，若传入的a和b是一个数组，那么就无法实现了

具体化模板

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<>)的Person版本来实现代码，具体化优先调用
template<> bool myCompare(Person & a, Person & b) {
	if (a.m_Age == b.m_Age && a.m_Name == b.m_Name) {
		return true;
	}
	else {
		return false;
	}
}
void main() {
	Person p1("Tom", 10);
	Person p2("Tom", 10);
	bool ret = myCompare(p1, p2);
	if (ret) {
		cout << "p1==p2" << endl;
	}
	else {
		cout << "p1!=p2" << endl;
	}
}

解释：模板的类型若为Person类型，那么自动调用具体化了的方法 

类模板

前言

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

语法： 

template<typename T>
类

解释：

  • template：声明创建模板
  • typename：表明其后面带符号的是一种数据类型（也可以用class替换）
  • T：通用的数据类型，名称可以替换，通常为大写字母

类模板与函数模板的区别

1.类模板没有自动类型推导的使用方式

template<class NameType,class AgeType>
class Person {
public:
	Person(NameType name, AgeType age) {
		this->m_Name = name;
		this->m_Age = age;
	}
	NameType m_Name;
	AgeType m_Age;
};
void main() {
	//类模板的使用（显式指定类型）
	Person<string, int> p("叶秋", 25);
	cout << "p的name：" << p.m_Name << endl << "p的age：" << p.m_Age << endl;
}

2.类模板在模板参数列表中可以有默认参数

//int为类模板的默认参数
template<class NameType,class AgeType=int>
class Person {
public:
	Person(NameType name, AgeType age) {
		this->m_Name = name;
		this->m_Age = age;
	}
	NameType m_Name;
	AgeType m_Age;
};
void main() {
	//类模板默认参数的使用
	Person<string> p("叶秋", 25);
	cout << "p的name：" << p.m_Name << endl << "p的age：" << p.m_Age << endl;
}

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

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

类模板对象做函数的参数

传入方式

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

具体案例

template<class NameType,class AgeType>
class Person {
public:
	Person(NameType name, AgeType age) {
		this->m_Name = name;
		this->m_Age = age;
	}
	void showPerson() {
		cout << "姓名：" << this->m_Name << "\t年龄：" << this->m_Age << endl;
	}
	NameType m_Name;
	AgeType m_Age;
};
//指定传入类型
void printPerson1(Person<string,int> &p) {
	p.showPerson();
}
//参数模板化
template<class T1 ,class T2>
void printPerson2(Person<T1,T2> &p) {
	p.showPerson();
}
//整个类模板化
template<class P>
void printPerson3(P &p) {
	p.showPerson();
}
void main() {
	Person<string, int> p("孙悟空", 100);
	printPerson1(p);
	printPerson2(p);
	printPerson3(p);
}

类模板与继承

前言

  • 当子类继承的父类是一个类模板时，子类在声明的时候需要指定父类的类型
  • 若不指定具体的类型，那么编译器无法给予子类分配内存
  • 若想灵活指定父类中T的类型，子类也需要变成类模板

子类指定具体类型案例

template<class T>
class Base {
	T m;
};
class Son:public Base<int> {};

子类不指定具体类型案例

template<class T>
class Base {
	T m;
};
template<class T>
class Son:public Base<T> {};

类模板成员函数的类外实现

template<class NameType,class AgeType>
class Person {
public:
	Person(NameType name, AgeType age);
	void showPerson();
	NameType m_Name;
	AgeType m_Age;
};
//构造函数的类外实现
template<class NameType, class AgeType>
Person<NameType,AgeType>::Person(NameType name,AgeType age){
	this->m_Name = name;
	this->m_Age = age;
}
//成员函数的类外实现
template<class NameType, class AgeType>
void Person<NameType, AgeType>::showPerson() {
	cout << "姓名：" << this->m_Name << "\t年龄：" << this->m_Age << endl;
}

注意：类模板中的成员函数类外实现时需要加上模板的参数列表

类模板分文件编写

1.直接包含源文件

person.h文件内

#pragma once
#include <iostream>
using namespace std;
template<class NameType, class AgeType>
class Person {
public:
	Person(NameType name, AgeType age);
	void showPerson();
	NameType m_Name;
	AgeType m_Age;
};

person.cpp文件内

#include "person.h"
//构造函数的类外实现
template<class NameType, class AgeType>
Person<NameType, AgeType>::Person(NameType name, AgeType age) {
	this->m_Name = name;
	this->m_Age = age;
}
//成员函数的类外实现
template<class NameType, class AgeType>
void Person<NameType, AgeType>::showPerson() {
	cout << "姓名：" << this->m_Name << "\t年龄：" << this->m_Age << endl;
}

执行文件内

//这里必须包含.cpp文件方可
#include "person.cpp"
void main() {
	Person<string, int> p("lili", 18);
	p.showPerson();
}

执行文件不可以包含.h文件必须包含.cpp问件原因：类模板中的成员函数在调用时才可以创建

2.将.h和.cpp文件中的内容写到一起，后将后缀名改为.hpp文件

person.hpp文件内

#pragma once
#include <iostream>
using namespace std;
template<class NameType, class AgeType>
class Person {
public:
	Person(NameType name, AgeType age);
	void showPerson();
	NameType m_Name;
	AgeType m_Age;
};

//构造函数的类外实现
template<class NameType, class AgeType>
Person<NameType, AgeType>::Person(NameType name, AgeType age) {
	this->m_Name = name;
	this->m_Age = age;
}
//成员函数的类外实现
template<class NameType, class AgeType>
void Person<NameType, AgeType>::showPerson() {
	cout << "姓名：" << this->m_Name << "\t年龄：" << this->m_Age << endl;
}

执行文件内

//这里必须包含.hpp文件
#include "person.hpp"
void main() {
	Person<string, int> p("lili", 18);
	p.showPerson();
}

类模板与友元

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

template<class T1,class T2>
class Person {
	//全局函数类内实现
	friend void printPerson(Person<T1,T2> p) {
		cout << "姓名：" << p.m_Name << "\t年龄：" << p.m_Age << endl;
	}
public:
	Person(T1 name, T2 age) {
		this->m_Name = name;
		this->m_Age = age;
	}
private:
	T1 m_Name;
	T2 m_Age;
};
void main() {
	Person<string, int> p("lili", 18);
	printPerson(p);
}

2.全局函数类外实现，需要让编译器知道该全局函数的存在

//编译器需要先知道printPerson函数的存在以及Person类的存在
template< class T1, class T2 >
class Person;
template<class T1, class T2>
void printPerson(Person< T1, T2 > p) {
	cout << "姓名：" << p.m_Name << "\t年龄：" << p.m_Age << endl;
}
template<class T1,class T2>
class Person {
	//全局函数类外实现
	//加空模板参数列表证明他是个模板函数
	//若全局函数是类外实现，需要让编译器提前知道这个函数的存在
	friend void printPerson<>(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;
};
void main() {
	Person<string, int> p("lili", 18);
	printPerson(p);
}

小白菜00
关注
  • 2
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++泛型编程
蹦跶跶
06-04 5622
C++泛型编程与STL总结1. 泛型编程1.1 模板1.2 函数模板1.2.1 语法1.2.2 使用函数模板方式1.2.3 普通函数和函数模板的区别1.2.4 普通函数与函数模板的调用规则1.2.5 模板的局限性1.3 类模板2. STL技术 1. 泛型编程 泛型编程最初诞生于C++中。目的是为了实现C++的STL（标准模板库）。其语言支持机制就是模板（Templates）。模板的精神其实很简单：参数化类型。换句话说，把一个原本特定于某个类型的算法或类当中的类型信息抽掉，抽出来做成模板参数T。（参考自Bai
C++ 泛型编程详解
01-21
泛型编程与面向对象编程的目标相同，即使重用代码和抽象通用概念的技术更加简单。但是面向对象编程强调编程的数据方面，泛型编程强调的是独立于特定数据类型。 这一篇介绍一下 C++ 编程中与面向对象并列的另一大分支——泛型编程，这一篇主要介绍函数模板、类模板和成员模板三大部分 如有侵权，请联系删除，如有错误，欢迎大家指正，谢谢 泛型编程 模板是泛型编程的一种重要思想，STL(Standard Template Library，标准模板库)是采用模板实现的一个实例 函数模板 对比函数重载(同一作用域内函数名相同，参数列表不同的函数)，函数模板只需要一个函数就实现了函数重载的部分功能(参数个数相同类型不同
C++f 泛型编程应用实例
07-13
集合了C++多重泛型应用实例，让初学者能够了解泛型编程的魅力，为学好C++ 打下良好基础。
C++泛型详解
最新发布
程序猿老樊的博客
03-10 1470
如果要在函数模板内部使用这样的类型，必须显示告诉编译器这个名字是一个类型，否则编译器无法得知它是一个类型还是一个值。模板形参可以是表示类型的类型形参（type parameter），也可以是表示常量表达式的非类型形参（nontype parameter）。编译器将确定用什么类型代替每个类型形参，用什么值代替每个非类型形参，然后产生并编译（称为实例化）该版本的函数。在定义的类模板中，使用模板形参作为类型或值的占位符，在使用类时再提供具体的类型或值。函数模板是一个独立于类型的函数，可以产生函数的特定类型版本。
关于C++泛型编程的一些杂感
03-02
关于GP，可以说我是对它有很复杂的感情的，其实GP这种东西最好是建立在无类型语言上面，就C++0X目前对GP的支持的趋势来看，确实如此，auto/varadictemplates这些特性的加入象征着C++GP的形式正越来越转向一种更纯粹的泛性语法描述，表面上你几乎不会看到任何类型的痕迹，只有语法以及语法背后蕴涵的语义，然而在C++里面有一个“最大的国情”，即支持所有这些的是一个坚实的大地——强类型系统。所有的泛化所有的模板代码一旦实例化之后就落实到某一集特定的类型身上然后接受强类型系统的考验;-)有点像波函数的塌缩——本来是具有无数可能的，一旦有了一个观测者立即就塌缩成一个实体。在GP中，观测
C++入门泛型编程介绍
m0_53421868的博客
12-06 8467
目录函数模板函数模板格式函数模板的实例化补充：类模板类模板的定义格式类模板的实例化 泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础 函数模板 函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。 函数模板格式 template<typename T1, typename T2,......,typename Tn> 返回值类型 函数名(参数列表){} 用不同类型的参数使用函数模板时，称为函数模板的实例.
C++ 泛型编程
zy1872071381的博客
08-26 628
C++泛型编程
【C++】泛型编程
weixin_45423515的博客
08-31 5300
为了让函数或者类有更好的复用性，C++引入了摸板的技术。让不同的数据类型，能使用到相同的函数或者类中去，这种编程的思想也叫做泛型编程。
C++中的泛型详细讲解
weixin_45805339的博客
11-30 5543
它是一种泛化的编程方式，其实现原理为程序员编写一个函数/类的代码示例，让编译器去填补出不同的函数实现。允许您延迟编写类或方法中的编程元素的数据类型的规范，直到实际在程序中使用它的时候。换句话说，泛型允许您编写一个可以与任何数据类型一起工作的类或方法。函数模板的声明和定义要放在一个头文件中。在部分使用场景，会使用.hpp来表示这个头文件是包含了函数定义的（即.h和.cpp的集合体）。需要注意，这并不是一个硬性要求，你也可以直接使用.h，并将声明和定义放入其中。因为单独的.h。
C++中的泛型编程
LWJLWJ_的博客
11-03 196
在计算机编程中，泛型编程是一种程序设计技巧，它允许程序员在设计程序时使用类型参数，从而实现代码的重用和扩展性。通过使用泛型，程序员可以编写出更加灵活、可重用的代码，而不需要为每种数据类型都编写特定的代码。通过使用泛型，程序员可以在不改变现有代码的情况下，为不同的数据类型提供统一的处理逻辑。模板是一种将数据类型作为一个参数的特殊函数或类，它可以在编译时根据实际的数据类型生成相应的代码。C++标准库中提供了许多通用的模板类和模板函数，如容器类（vector、list等）、算法（sort、find等）等。
C++数据结构--泛型编程
m0_73443478的博客
02-07 313
C++数据结构--泛型编程
C++的泛型编程
m0_64527760的博客
03-07 209
通过定义模板类和模板函数，我们可以在编写代码时不指定具体的数据类型，而是使用模板参数来表示类型。这样一来，我们可以在不同的场景下使用相同的代码，只需要根据需要传入不同的数据类型。通过使用模板，我们可以编写通用的代码，它可以适用于不同的数据类型，同时避免了重复编写类似的代码。通过泛型编程，我们可以编写更加通用和灵活的代码，提高代码的质量和效率，减少代码的重复和冗余。C++的泛型编程是指使用模板技术来实现通用的代码，使得可以在不同的数据类型上进行操作，而无需编写针对不同类型的重复代码。
【C++】C++面向对象，泛型编程总结篇（封装，继承，多态，模板）|（秋招篇）
weixin_46274756的博客
08-06 453
【C++】C++面向对象，泛型编程总结篇（封装，继承，多态，模板）|（秋招篇）
C++ 中的泛型
我的博客，不一样的自我表达
08-02 448
简单的想法就是将数据类型作为参数传递，这样我们就不需要为不同的数据类型编写相同的代码。我们可以编写一个 sort() 并将数据类型作为参数传递，而不是编写和维护多个代码。泛型是允许类型（整数、字符串等和用户定义类型）成为方法、类和接口的参数的想法。如果数据类型是整数、字符串或字符，则无需创建不同的算法。与函数模板一样，当类定义独立于数据类型的内容时，类模板非常有用。我们编写一个可用于不同数据类型的通用函数。函数模板的示例有 sort()、max()、min()、printArray()
C++泛型编程和apollo
04-30
C++ 泛型编程是一种利用模板来实现代码复用和泛化的技术，可以大大提高代码的灵活性和重用性。C++的模板机制非常强大，可以实现各种高级的泛型编程技巧，比如模板元编程、SFINAE技术等。而在C语言中，由于没有模板...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值