C++[模板]

最新推荐文章于 2024-11-05 23:37:40 发布
最新推荐文章于 2024-11-05 23:37:40 发布
阅读量164 收藏
点赞数
分类专栏： 临时分类 文章标签： 程序人生 windows visual studio 开发语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43281363/article/details/129584977
版权
本文详细介绍了C++中的模板概念，包括函数模板和类模板的定义、使用方式、实现机制。讨论了普通函数与函数模板的区别，以及模板的局限性和解决方法。此外，还涵盖了类模板作为函数参数、继承、成员函数的类内外实现，以及类模板分文件编写的问题和友元的实现。
摘要由CSDN通过智能技术生成 
2023-3-16首次编辑

C++[模板]

Unit 9:模板

一.模板的概念

  • 通用的函数或类,里面的数据类型有多种状态
  • 模板有 : 函数和类

二.函数模板

函数模板:

  • 建立一个通用函数
  • 其函数类型和形参类型不具体制定
  • 用一个虚拟的类型来代表
#define _CRT_SECIRE_NO_WARNINGS
#include <iostream>
using namespace std;

//A.定义函数模板
template<class T>
//代表泛型的数据类型
//让编译器看到这句话后面紧跟着的函数中有T不要报错
void mySwap1(T &a, T &b)
{
	T tmp = a;
	a = b;
	b = tmp;
}

//也可以这样定义函数模板
template<typename T>
void mySwap2(T a, T b)
{

}

//B.使用函数模板
void test1()
{
	int a = 10;
	int b = 20;

	//1.编译器会根据实参来自动推导数据类型
	mySwap1(a, b);
	/*
	编译器会在函数模板或类模板被调用时,会进行二次编译
	void mySwap1(int &a, int &b)
	{
	int tmp = a;
	a = b;
	b = tmp;
	}
	*/
	cout << "a=" << a << endl;
	cout << "b=" << b << endl;
	char c = 'c';
	//mySwap1(a, c); //err:数据类型要一致

	//2.显式的指定类型
	mySwap1<int>(a, b); //<>用参数列表告诉编译器我只传int类
	//mySwap1<double>(a, b); //注意:指定类型,传入时不能不一致

	//mySwap2<>(); //err:调用时,必须让编译器知道泛型T具体是什么类型
}

template<class T>
T func(T a, T b)
{
	return a + b;
}

void test2()
{
	int a = 10;
	int b = 20.2;
	cout << func<int>(a, b) << endl;
	//隐式转换:
	//如果使用参数列表指定数据类型,那么实参中可以隐式转换
	//转换成功,就调用
	//转换失败,就报错
}

int main()
{
	test1();
	test2();
	system("pause");
	return 0;
}

三.普通函数与函数模板

#define _CRT_SECIRE_NO_WARNINGS
#include <iostream>
using namespace std;

//普通函数
int myPlus1(int a, int b)
{
	return a + b;
}

//函数模板
template<class T>
int myPlus2(T a, T b)
{
	return a + b;
}

//A.普通函数与函数模板的区别
void test1()
{
	int a = 10;
	int b = 20;
	char c = 'c';

	//普通函数可以进行隐式转换
	myPlus1(a, c);

	//函数模板不能直接进行隐式转换
	//myPlus2(a, c); //err
	myPlus2<int>(a, c); //如果要进行隐式转换,必须加上参数列表
}

//普通函数
void myPlus(int a, int b)
{
	cout << "普通函数" << endl;
}

//函数模板
template<class T>
void myPlus(T a, T b)
{
	cout << "函数模板" << endl;
}

template<class T>
void myPlus(T a, T b, T c)
{
	cout << "函数模板T c" << endl;
}

//B.普通函数与函数模板的调用规则
void test2()
{
	int a = 10;
	int b = 20;

	//1.函数模板和普通函数可以重载
	//2.如果普通函数和函数模板都可以实现功能,普通函数优先调用
	myPlus(a, b);

	//3.可以使用<>空参数列表强制调用函数列表
	myPlus<>(a, b);

	//4.函数模板之间也可以进行重载
	//5.如果函数模板可以产生更好的匹配,那么优先使用函数模板
	char c1 = 'a';
	char c2 = 'b';
	myPlus(c1, c2);
}

int main()
{
	test1();
	test2();
	system("pause");
	return 0;
}

四.模板实现机制

编译器并不是把函数模板处理成能够处理如何类型的函数
函数模板通过具体类型产生不同的函数
编译器会通过对函数模板进行两次编译：

  1. 在声明的地方对模板代码本身进行编译
  2. 在调用的地方对参数替换后的代码进行编译

五.模板的局限性及解决方法

#define _CRT_SECIRE_NO_WARNINGS
#include <iostream>
#include <string>
using namespace std;

//类模板的定义
template<class NameType, class AgeType>
class Maker1
{
public:
	Maker1(NameType name, AgeType age)
	{
		this->name = name;
		this->age = age;
	}
	void printMaker()
	{
		cout << "name=" << name << endl;
		cout << "age=" << age << endl;
	}
public:
	NameType name;
	AgeType age;
};

//类模板的使用
void test1()
{
	//1.类模板不会自动推导数据类型,要显示的告诉编译器是什么类型
	Maker1<string, int> m1("悟空", 18);
	m1.printMaker();

	//2.注意传入的参数,传入参数类型要程序员自己把握
	Maker1<int, int> m2(18, 20);
	m2.printMaker();

	//Maker<> m3("aaa", 18); //err:必须通过参数列表告诉编译器是什么类型
}

//类模板的默认类型
template<class NameType, class AgeType=int>
class Maker2
{
public:
	Maker2(NameType name, AgeType age)
	{
		this->name = name;
		this->age = age;
	}
	void printMaker()
	{
		cout << "Name:" << name << endl;
		cout << "Age:" << age << endl;
	}
public:
	NameType name;
	AgeType age;
};

void test2()
{
	//如果有默认类型,那么<>里面可以少写类型
	Maker2<string> m1("贝吉塔", 20);
	m1.printMaker();

	//以传入的类型为准
	Maker2<string, double> m2("比克", 183.33);
	m2.printMaker();
}

//默认类型后面的泛型类型都必须有默认类型
template<class NameType, class AgeType = int, class T = int>
class Maker3
{
public:
	Maker3(NameType name, AgeType age)
	{
		this->name = name;
		this->age = age;
	}
	void printMaker()
	{
		cout << "Name=" << name << endl;
		cout << "Age=" << age << endl;
	}
public:
	NameType name;
	AgeType age;
};

int main()
{
	test1();
	test2();
	system("pause");
	return 0;
}

类模板和函数模板的区别：

  • 类模板不会自动推导数据类型，要显示的告诉编译器是什么类型
  • 函数模板可以根据实参来推导数据类型

六.类模板做函数参数

#define _CRT_SECIRE_NO_WARNINGS
#include <iostream>
#include <string>
using namespace std;

template<class NameType, class AgeType>
class Maker
{
public:
	Maker(NameType name, AgeType age)
	{
		this->name = name;
		this->age = age;
	}
	void printMaker()
	{
		cout << "Name:" << name << endl;
		cout << "Age:" << age << endl;
	}
private:
	NameType name;
	AgeType age;
};

//1.指定传入的数据类型
void func1(Maker<string, int> &m)
{
	m.printMaker();
}

//2.参数模板化
template<class T1, class T2>
void func2(Maker<T1, T2> &m)
{
	m.printMaker();
}

//3.整个类模板化
template<class T>
void func3(T &m)
{
	m.printMaker();
}

void test()
{
	Maker<string, int> m("悟空", 18);
	func1(m);
	func2(m);
	func3(m);
}

int main()
{
	test();
	system("pause");
	return 0;
}

七.类模板的继承

#define _CRT_SECIRE_NO_WARNINGS
#include <iostream>
using namespace std;

//普通类继承类模板
template<class T>
class Father
{
public:
	Father()
	{
		m = 20;
	}
public:
	T m;
};

//普通类继承类模板
//要告诉编译器父类的泛型数据类型具体是什么类型
class Son1 :public Father<int>
{
public:

};

//类模板继承类模板
template<class T1, class T2>
class Son2 :public Father<T2>
{
public:

};

int main()
{

	system("pause");
	return 0;
}

八.类模板的成员函数类内类外实现

#define _CRT_SECIRE_NO_WARNINGS
#include <iostream>
using namespace std;

//1.类内实现
template<class NameType, class AgeType>
class Maker1
{
	Maker1(NameType name, AgeType age)
	{
		this->name = name;
		this->age = age;
	}
	void printMaker()
	{
		cout << "Name:" << this->name << endl;
		cout << "Age:" << this->age << endl;
	}
public:
	NameType name;
	AgeType age;
};

//2.类外实现
//成员函数必须写成函数模板,并且写上参数列表
template<class NameType, class AgeType>
class Maker2
{
public:
	Maker2(NameType name, AgeType age);
	void printMaker();
public:
	NameType name;
	AgeType age;
};

template<class NameType, class AgeType>
Maker2<NameType, AgeType>::Maker2(NameType name, AgeType age)
{
	cout << "构造函数" << endl;
	this->name = name;
	this->age = age;
}

template<class NameType, class AgeType>
void Maker2<NameType, AgeType>::printMaker()
{
	cout << "Name:" << this->name << endl;
	cout << "Age:" << this->age << endl;
}

int main()
{

	system("pause");
	return 0;
}

九.类模板分文件编写问题及解决方法

问题:

  • 调用类模板时
  • 要进行二次编译
  • 要把泛型的数据类型替换为具体的类型
  • 此时需要知道函数体
  • 但函数的实现在.cpp中
  • 那么调用类模板的.cpp中并没有引入实现的,cpp
  • 只引入了.h,所以报错

解决方法:

  • 把成员函数放到.h中
  • 然后把.h改为.hpp
  • 最后在调用成员函数的地方引入.hpp

在类调用模板的地方引入.hpp,不会报错(重定义):

  • 类的成员函数默认申请为内联函数
  • 在链接时,链接器会对重复的成员函数进行处理
  • 只保留一份成员函数,所以不会报错

十.类模板与友元

#define _CRT_SECIRE_NO_WARNINGS
#include <iostream>
#include <string>
using namespace std;

//A.友元类内实现
template<class NameType, class AgeType>
class Maker1
{
	friend void printMaker1(Maker1<NameType, AgeType> &p)
	{
		cout << "类内实现" << endl;
		cout << "Name:" << p.name << endl;
		cout << "Age:" << p.age << endl;
	}

public:
	Maker1(NameType name, AgeType age)
	{
		this->name = name;
		this->age = age;
	}
private:
	NameType name;
	AgeType age;
};

void test1()
{
	Maker1<string, int> m("悟空", 18);
	printMaker1(m);
}

//B.友元类外实现
//1.声明类模板
template<class NameType, class AgeType>
class Maker2;

//2.声明函数模板
//告诉编译器下面有printMaker2的实现
template<class NameType, class AgeType>
void printMaker2(Maker2<NameType, AgeType> &p);


template<class NameType, class AgeType>
class Maker2 
{
	//3.在函数名和()之间加上<>
	friend void printMaker2<>(Maker2<NameType, AgeType> &p);
	//编译器不知道printMaker2在下面有没有实现,需要知道函数的结构

public:
	Maker2(NameType name, AgeType age)
	{
		this->name = name;
		this->age = age;
	}
private:
	NameType name;
	AgeType age;
};

//4.友元在类外实现要写成函数模板
template<class NameType, class AgeType>
void printMaker2(Maker2<NameType, AgeType> &p)
{
	cout << "类外实现" << endl;
	cout << "Name:" << p.name << endl;
	cout << "Age:" << p.age << endl;
}

void test2()
{
	Maker2<string, int> m("贝吉塔", 18);
	printMaker2(m);
}

int main()
{
	test1();
	test2();
	system("pause");
	return 0;
}
Cforikl_
关注
专栏目录
《 C++模板》和《C++模板元编程》两本
03-20
C++模板是C++语言中的一个强大特性，它允许程序员创建泛型代码，即能够处理多种数据类型的代码。模板在C++中分为两种主要类型：函数模板和类模板。函数模板用于定义可以接受不同类型参数的函数，而类模板用于创建...
C++模板与STL库介绍
03-18
C++模板和STL库是C++编程语言中的两个核心特性，它们极大地提高了代码的复用性和效率。本文将深入探讨这两个主题，并提供丰富的实践应用示例。 首先，我们来理解C++模板。模板是C++的一个强大工具，它允许程序员...
c++ 模板
weixin_40026739的博客
06-16 1万+
模板是c++的一种特性，允许函数或者类（对象）通过泛型（generic types）的形式表现或者运行模板可以使得函数或类在对应不同的类型（types）的时候正常工作，而无需为每一种类型分别写一份代码。1：函数模板（function tempalte）：使用泛型参数的函数（function with generic parameters）2：类模板（class template）：使用泛型参数的类（class with generic parameters）模板的声明（declaration）其实并未给出一
C++模板编程
努力学习游泳的鱼的博客
09-21 1375
C++模板编程是一种强大的工具，它允许程序员编写与类型无关的代码，从而提高代码的复用性和灵活性。通过函数模板和类模板，程序员可以编写通用的函数和类，处理各种类型的数据。此外，模板还支持特化、元编程和变长参数等高级特性，进一步扩展了其应用范围。
C++ 模板
weixin_44235615的博客
03-19 1809
基本概念：模板就是建立通用的模具，大大提高代码的复用性。 特点： 模板不可以直接使用，只是一个框架 模板的通用并不是万能的 泛型编程主要利用的思想就是模板 模板分为函数模板和类模板 总结： 函数模板利用关键字template 使用函数模板有两种方式：自动类型推导、显示指定类型 模板的目的是为了提高复用性，将类型参数化 注意事项： 自动类型推导，必须推导出一致的数据类型T，才可以使用 模板必须要确定出T的数据类型，才可以使用 普通函数与函数模板的区别： 普通函数调用时可以发生自动类型转换
C++模板
weixin_63246738的博客
05-19 6160
c++的模板
c++模板函数
weixin_48984572的博客
09-06 2655
c++函数模板概念，重载，调用
C++模板——template
热门推荐
原来45的博客
06-11 3万+
目录1. 模板2. 函数模板2.1 函数模板概念2.2 函数模板格式2.3 函数模板原理2.4 函数模板的实例化2.5 模板参数的匹配原则2.6 声明定义分离3. 类模板3.1 类模板格式3.2 类模板的实例化3.3 类模板中函数放在类外进行定义时4. 模板分离编译4.1 什么是分离编译4.2 模板的分离编译5. 缺省值，返回值6. 总结...
C++模板（template）
TU^的博客
08-04 2701
【优点】1、 模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生2、 增强了代码的灵活性【缺陷】1、 模板会导致代码膨胀问题，也会导致编译时间变长2、 出现模板编译错误时，错误信息非常凌乱，不易定位错误。
C++模板(函数模板/类模板)
DR5200的博客
10-05 5345
文章目录一.泛型编程二.函数模板 一.泛型编程 在引入泛型编程之前,我们先来看这样一个问题,怎么做到实现一个通用的交换函数呢? 在C语言阶段我们可能会像下面这样写,需要分别实现不同类型的交换函数,又由于C语言不允许出现同名函数,所以函数名也需要不一样,写起来很繁琐 void Swapi(int* e1, int* e2) { int tmp = *e1; *e1 = *e2; *e2 = tmp; } void Swapd(double* e1, double* e2) { double tmp =
C++模板特化
习惯有你
12-24 1523
模板特化 在学习模板的时候我们用模板来解决了一个add模板函数，实现不同类型的传参相加，实践证明，模板函数比普通函数好用。那么现在如果我们要新增一个需求，就是如果传入的是两个string类型的参数，我们不要简单的拼接，我们要在两个字符串之间添加一个空格，显然模板函数已经无法满足我们的要求，解决方法就是使用模板特化，简单说就是模板的一个特殊化，当传参为两个string类型的时候，不调用模板函数，而是调用特化模板函数，传入其它类型的时候，仍然使用模板函数，如下示例： template &l...
C++模板详解
qq_52905520的博客
10-21 1万+
C++模板详解
《C++模板元编程实战：一个深度学习框架的初步实现》.zip
12-26
《C++模板元编程实战：一个深度学习框架的初步实现》是一本专注于C++模板元编程在实际项目中应用的书籍，尤其是将其应用于构建深度学习框架的实例。模板元编程是C++语言中的一种编译时编程技术，它允许开发者在编译...
2024年1024程序人生总结
CloudHuCoding
10-24 1382
大家的日子都难熬的时候，就希望把对方先熬死，这样可以靠着吸对方的血过日子，这就是竞争的残酷之处，非我族类其心必异，不存在相濡以沫，只存在“死道友，不死贫道”，这就是残酷的经济搏杀。中美的经济博弈，谁输谁赢还很难讲，毕竟大洋彼岸曾经的奢华已不复往昔，罢工的罢工，停产的停产，铁锈带继续生锈，老百姓的日子很难过，所以才有了越来越普遍的零元购。现在的经济从通胀变成通缩，这代表经济不活跃了，就业机会少了，大家没了工资收入，创业又难上加难，这导致大家都不敢消费了，就怕哪天失业了却没有存款。为什么喜欢Bevy呢？
数据结构题集-第二章-线性表-单链表的删除
最新发布
georangel
11-05 272
没想到单链表的删除也有很多情况需要考虑，以前一直以为链表很简单，几分钟就能完成与之有关的各种操作，不知为什么，遇到题集中的算法要求后需要注意这么多已知和未知的差错。
一篇文章速通Java开发Stream流（流水线开发附斗地主小游戏综合案例）
Bew1tch的博客
11-05 761
有filiter过滤、sorted排序、按sorted照指定规则排序、limit获取前几个元素、skip跳过前几个元素、distinct去除流中重复的元素、map对元素进行加工，并返回对应的新流、concat合并a和b两个流为一个流...每次运行的结果都是随机的，默认是令狐紫为地主，多三张牌，自动发牌，自动按大小排序。这一部分讲的就是Stream的中间方法，对于流水线上数据进行处理的部分。终结方法指的是调用完成后，不会返回新Stream了，没法继续使用流了。，功能强大，性能高效，
PythonBase02
tyb333333的博客
11-05 798
python基础第二部分
Java 基础教学：高级特性与实战-集合框架
世间万物皆不如你
11-05 300
Java 集合框架提供了一组丰富的类和接口，用于在应用程序中高效地管理数据集合。ListSet和Map是最基本的集合类型，每种类型都有不同的特点和用途。了解何时使用哪种类型的集合以及如何正确地使用它们，对于编写高效、易于维护的 Java 程序至关重要。
C++模板元编程深度探索
"C++模板元编程相关学习资料" C++模板元编程是一种在编译时进行计算和代码生成的技术，它是C++语言的一个强大特性，允许程序员利用模板机制来实现泛型编程的更高层次抽象。模板元编程通常涉及到类型级别的计算，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Cforikl_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值