C++之泛型编程

最新推荐文章于 2024-09-29 14:03:21 发布
最新推荐文章于 2024-09-29 14:03:21 发布
阅读量1.9k 收藏 10
点赞数 2
分类专栏： C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60027772/article/details/128172671
版权
本文深入探讨C++的模板机制，包括函数模板和类模板的使用、区别及注意事项。函数模板允许创建通用函数，类模板则用于构建通用类。内容涵盖模板特点、自动类型推导、模板具体化、类模板成员函数的创建时机、类模板与继承、友元等关键概念，旨在提升代码复用性和泛型编程能力。
摘要由CSDN通过智能技术生成

目录

模板

模板的特点

函数模板

前言

函数模板的使用方式

函数模板具体案例

使用模板的注意事项

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

具体案例

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

模板的局限性

具体化模板

类模板

前言

类模板与函数模板的区别

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

类模板对象做函数的参数

传入方式

具体案例

类模板与继承

前言

子类指定具体类型案例

子类不指定具体类型案例

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

类模板分文件编写

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
关注
专栏目录
C++泛型编程
蹦跶跶
06-04 6508
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++的罗浮宫
06-13 4万+
  泛型编程：源起、实现与意义 By 刘未鹏C++的罗浮宫(http://blog.csdn.net/pongba)(去年12月《程序员》的约稿)(以前也写过一篇相关的文章：Generic Programming - What Are You, anyway? ) 为什么泛型泛型编程（Generic Programming）最初提出时的动机很简单直接：发明一种语
【C++】泛型编程
weixin_45423515的博客
08-31 5693
为了让函数或者类有更好的复用性，C++引入了摸板的技术。让不同的数据类型，能使用到相同的函数或者类中去，这种编程的思想也叫做泛型编程。
c++泛型编程
weixin_63207763的博客
09-29 1511
STL的代码从广义上讲分为三类：algorithm（算法）、container（容器）和iterator（迭代器），几乎所有的代码都采用了模板类和模板函数的方式，这相比于传统的由函数和类组成的库来说提供了更好的代码重用机会。容器是存储数据的集合，存储的数据元素可以是任何类型，因为容器是模板实现的。vector内部通过数组实现，但是vector是可变长的，因此每次长度变化时，内部重新创建数组，能高效地进行随机存取（数组的内存连续），但是不擅长插入删除。// end返回一个迭代器指针，指向最后一个元素的后面。
C++ 泛型编程
weixin_43791477的博客
05-24 971
`STL`是一种泛型编程(`generic programming`)。面向对象编程关注的是编程的数据方面，而泛型编程关注的是算法。它们之间的共同点是抽象和创建可重用代码，但它们的理念绝然不同。 模板使得算法独立于存储的数据类型，而迭代器使算法独立于使用的容器类型。因此，它们都是`STL` 通用方法的重要组成部分。
C++--泛型编程
diyxuan的博客
07-08 1170
泛型编程的使用方法以及应用实例
C++中的泛型编程
木子皿--啥都不会的菜鸟
02-13 495
文章目录1 C++中的泛型编程1.1 引入1.2 泛型编程 1 C++中的泛型编程 1.1 引入 发散性问题：C++中有几种交换变量的方法？ 交换变量的方法：定义宏代码块和定义函数。 示例代码如下： #include <iostream> #include <string> using namespace std; #define SWAP(t, a, b) \ ...
C++程序设计与实践：11-模板和泛型编程.ppt
06-12
C++程序设计与实践：模板和泛型编程 C++ 程序设计与实践中，模板和泛型编程是非常重要的概念。模板是 C++ 的泛型机制，用来实现泛型编程。泛型编程是指不依赖于任何具体类型来编写通用代码，具体类型信息的提供是在...
C++STL泛型编程ppt课件.pptx
10-03
C++STL泛型编程ppt课件.pptx
C++模板与泛型编程详解及实战应用
最新发布
10-22
内容概要：本文详细介绍了C++模板和泛型编程的基础知识、进阶技术和实战应用。主要内容包括模板的概念与优势、函数模板和类模板的声明与实例化、模板元编程、SFINAE原则、模板特化与偏特化、类型推导与auto关键字、...
C++泛型基础
weixin_34233421的博客
06-04 1183
1.泛型的基本思想 泛型编程（Generic Programming）是一种语言机制，通过它可以实现一个标准的容器库。像类一样，泛型也是一种抽象数据类型，但是泛型不属于面向对象，它是面向对象的补充和发展。在面向对象编程中，当算法与数据类型有关时，面向对象在对算法的抽象描述方面存在一些缺陷。比如对栈的描述：class stack{    push(参数类型)  //入栈算法    pop(参数...
C++的泛型编程
Albert_weiku的博客
06-23 961
屏蔽掉数据和操作数据的细节，让算法更为同意通用，让编程者更多地关注算法的结构，而不是在算法中处理不同的数据类型
C++ 的泛型编程
weixin_62789590的博客
07-15 782
这个思想其实有两个层面，1、编写与数据类型无关的代码；2、使用模版元；
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值