【C++】模板

已于 2024-06-20 16:25:04 修改
阅读量990 收藏 8
点赞数 28
分类专栏： C++ 文章标签： c++ 开发语言
于 2024-06-02 14:58:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_50921201/article/details/139375512
版权

学习C++模板有关的笔记
如果有不正确或者需要补充的，敬请指教

文章目录

前言

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

一、函数模板

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

1.1 函数模板语法

语法：
template<typename T>
函数声明或定义
  • template —声明创建模板
  • typename —表面其后面的符号是—种数据类型，可以用class代替
  • T —通用的数据类型，名称可以替换，通常为大写字母

使用函数类型模板有两种方式：自动类型推导、显示指定类型

#include<iostream>
using namespace std;

//函数模板
//声明一个模板,告诉编译器后面的代码中紧跟着的T不要报错，T是一个通用数据类型
template<typename T>
void MySwap(T& a, T& b){
	T Temp = a;
	a = b;
	b = Temp;
}
//测试函数
void test01(){
	int a = 10;
	int b = 20;
	//利用函数模板进行交换
	//1. 自动类型推导
	MySwap(a, b);
	cout << a  << endl;
	cout << b << endl;

	double c = 11.1;
	double d = 12.2;
	//2. 显示指定类型
	MySwap<double>(c, d);
	cout << c << endl; //12.2
	cout << d << endl; //11.1
}
int main(void){
	test01();
	system("pause");
	return 0;
}

1.2 函数模板使用事项

  • 自动类型推导，必须推导出一致的数据类型T才能使用
    • 也就是对于传入的参数或者返回值的类型，用T代替时，T只能表示一种类型
  • 模板必须要确定出T的数据类型，才可以使用
    • 在调用模板函数时，必须能确定出T的类型
#include<iostream>
using namespace std;
//实现通用 对数组进行排序的函数
//规则 从大到小
//算法 选择 
//测试 char 数组 int 数组
//交换的函数模板
template<class T>
void mySwap(T& a, T& b){
	T temp = a;
	a = b;
	b = temp;
}

template<class T>
void mySort(T arr[],int len){
	for (int i =  0; i < len; i++){
		int max = i;//认定最大值的下标
		for (int j = i + 1; j < len; j++){
			//认定的最大值比遍历出的数值要小，说明j下标的元素才是真正的最大值
			if (arr[max] < arr[j]){
				max = j;
			}
		}
		if (max != i){
			//交换max和i元素
			mySwap(arr[max], arr[i]);
		}
	}
}

//打印数组模板
template<class T>
void myPrint(T arr[], int len){
	for (int i = 0; i < len; i++){
		cout << arr[i]<< endl;
	}
}

//字符数组排序测试函数
void test01(){
	char charArr[] = "badcfe";
	int num = sizeof(charArr) / sizeof(char);
	mySort(charArr, num);
	myPrint(charArr, num);
}
//整型数组排序测试函数
void test02(){
	int intArr[] = {2,3,78,9,7};
	int num = sizeof(intArr) / sizeof(int);
	mySort(intArr, num);
	myPrint(intArr, num);
}

int main(void){
	test01(); 
	test02();
	return 0;
}

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

  • 普通函数调用时可以发生自动类型转换(隐式类型推导)
  • 函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
    • 如果利用显式指定类型的方式，可以发生隐式类型转换
#include<iostream>
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;

	//自动类型推导不行
	//cout << myAdd02(a, c) << endl;

	//显式指定类型行
	cout << myAdd02<int>(a, c) << endl;
}

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

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

调用规则如下：

  • 如果函数模板和普通函数都可以实现，优先调用普通函数
  • 可以通过空模板参数列表来强制调用函数模板
  • 函数模板也可以发生重载
  • 如果函数模板可以产生更好的匹配，优先调用函数模板
#include<iostream>
using namespace std;
void myPrint(int a, int b){
	cout << "调用普通函数" << endl;
}

template<class T>
void myPrint(T a, T b){
	cout << "调用模板" << endl;
}

// 函数模板也可以进行重载
//如果时重载的处理特定数据类型，需要将class T删去，留下空尖括号
template<class T>
void myPrint(T a, T b,T c){
	cout << "调用重载模板" << endl;
}

void test01(){
	int a = 10;
	int b = 20;
	//如果函数模板和普通函数都可以调用。优先调用普通函数。普通函数只有声明会报错
	myPrint(a, b);

	//通过空模板的参数列表强制调用函数模板
	myPrint<>(a,b);

	//调用重载模板
	myPrint(a, b, 100);

	//如果函数模板产生更好的匹配，优先调用函数模板
	char c1 = 'a';
	char c2 = 'b';

	myPrint(c1, c2); //因为是两个char类型，自动类型推导时，更好的匹配，所以调用模板
}
int main(void){
	test01();
	system("pause");
	return 0;
}

1.5 模板的局限性

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

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

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

二、类模板

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

2.1 类模板语法

语法
template<typename T>
类
  • template< typename T>——声明创建模板
  • typename —— 表明其后面的符号是一种数据类型，可以用class代替
  • T —— 通用的数据类型，名称可以替换，通常为大写字母
#include<iostream>
#include<string>
using namespace std;
//类模板
template<class NameType,class AgeType>
class Person{
public:
	Person(NameType name, AgeType age){
		this->m_Age = age;
		this->m_Name = name;
	}
	
	void showPerson(){
		cout << this->m_Name << this->m_Age << endl;
	}
	NameType m_Name;
	AgeType m_Age;
};

void test01(){
	// 实例化类模板对象，<>中是模板的参数列表
	Person<string, int>p1("张三",10);
	p1.showPerson();
}

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

2.2 类模板与函数模板的区别

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

  • 类模板没有自动类型推导的使用方式
  • 类模板在模板参数列表中可以有默认参数
#include<iostream>
#include<string>
using namespace std;

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 << this->m_Name << this->m_Age << endl;
	}
	NameType m_Name;
	AgeType m_Age;
};

//类模板没有自动类型推导的使用方式
void test01(){
	//Person p("李四", 13);
	Person<string,int>p("李四", 13);//只能用显示指定类型
	p.ShowPerson();
}

//类模板在模板参数列表中可以有默认参数
void test02(){
	Person<string>p2("张三", 13);
}

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

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

类模板中成员函数和普通类中成员函数创建实际是有区别的:

  • 普通类中的成员函数一开始就可以创建
  • 类模板中的成员函数在调用时才创建
#include<iostream>
#include<string>
using namespace std;

//类模板中的成员函数在调用时才去创建

//定义Person1类
class Person1 {
public:
	void showPerson1(){
		cout << "Person show1" << endl;
	}
};

//定义Person2类
class Person2{
public:
	void showPerson2(){
		cout << "Person show2" << endl;
	}
};
template<class T>
class MyClass{
public:
	T obj;
	//类模板中的成员函数
	void func1(){
		obj.showPerson1();
	}
	void func2(){
		obj.showPerson2();
	}
};

void test01(){
	//确定类模板中T为Person1类型
	MyClass<Person1>m;
	m.func1();
	//m.func2(); // 则func2()不能调用，因为showPerson2()属于Person2类
	// 只要不调用func2()，就不报错，因为类模板中的成员函数在调用时才创建
}
int main(void){
	test01();
	system("pause");
	return 0;
}

2.4 类模板对象做函数参数

类模板实例化出的对象，向函数传参的方式

一共有三种传入方式

  1. 指定传入的类型——直接显式对象的数据类型
  2. 参数模板化——将对象中的参数变为模板参数进行传递
  3. 整个类模板化——将这个对象类型，模板化进行传递
#include<iostream>
using namespace std;

//类模板对象做函数参数
template<class T1,class T2>
class Person{
public:
	Person(T1 name,T2 age){
		this->m_Name = name;
		this->m_Age = age;
	}

	void showPerson(){
		cout << this->m_Name << this->m_Age << endl;
	}
	T1 m_Name;
	T2 m_Age;
};

//1.指定传入类型，作为PrintPerson1的参数
void PrintPerson1(Person<string,int>&p){
	p.showPerson();
}
void test01(){
	Person<string, int>p1("张三",11);
	PrintPerson1(p1);
}

//2.在函数前加上template，将传入的类参数模板化
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;
}
void test02(){
	Person<string, int>p2("李四", 12);
	PrintPerson2(p2);
}

//3.整个类模板化，也就是将PrintPerson3的参数作为T进行模板化
template<class T>
void PrintPerson3(T &p){
	p.showPerson();
	cout << "T的数据类型为" << typeid(T).name() << endl;
}
void test03(){
	Person<string, int>p3("赵四", 14);
	PrintPerson3(p3);
}
int main(void){
	test01();
	test02();
	test03();
	system("pause");
	return 0;
}

2.5 类模板与继承

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

//类模板与继承
template<class T>
class Base{
	T m;
};
//必须要知道父类中T的数据类型才能继承给子类
class Son :public Base<int>{

};
void test01(){
	Son s1;
}

//如果想灵活指定父类中T类型，子类也需要变类模板
template<class T1,class T2>
class Son2 :public Base<T2>{
public:
	Son2(){
		cout << typeid(T1).name()<< endl; //int
		cout << typeid(T2).name()<< endl; //char
	}
	T1 obj;
};
void test02(){
	Son2<int, char>s2;
}
int main(void){
	test02();
	system("pause");
	return 0;
}

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

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

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

//类模板成员函数类外实现
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 << this->m_Name << this->m_Age << endl;
}
void test01(){
	Person<string, int>p1("新二", 13);
	p1.showPerson();
}
int main(void){
	test01();
	system("pause");
	return 0;
}

2.7 类模板分文件编写（.h与.cpp）

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

解决：

  • 解决方式1：在头文件直接包含实现类模板成员函数的.cpp源文件。
  • 解决方式2：将声明.h和实现.cpp在到同一个文件中，并更改后缀名为.hpp。hpp是约定俗成的名称，并不是强制。然后在头文件中包含.hpp文件。

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

Person.hpp文件：

#pragma once
#include<iostream>
using namespace std;

//类模板
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 << this->m_Name << this->m_Age << endl;
}

主函数文件中：

#include<iostream>
#include"Person.hpp" //包含该.hpp文件
using namespace std;
#include<string>

void test01(){
	Person<string, int>p1("伞兵", 18);
	p1.showPerson();
}
int main(void){
	test01();
	system("pause"); 
	return 0;
}

2.8 类模板与友元

全局函数类内实现，直接在类内声明友元即可
全局函数类外实现比较复杂，需要提前让编译器知道全局函数的存在，如果全局函数用到了类模板，则类模板还需要提前声，如下。

#include<iostream>
#include<string>
using namespace std;
//通过全局函数打印Person的信息

//提前让编译器知道Person类的存在
template<class T1, class T2 >
class Person;

//类外实现
template<class T1, class T2>
void PrintPerosn2(Person<T1, T2>p){
	cout << "类外实现" << p.m_Name << p.m_Age < endl;
}

template<class T1,class T2 >
class Person{
	//全局函数类内实现
	friend void PrintPerosn(Person<T1,T2>p){
		cout << p.m_Name << p.m_Age << endl;
	}

	//全局函数类外实现
	//注意：加空模板参数列表
	//如果全局函数 是类外实现 需要让编译器提前知道这个函数的存在，也就是类模板之前
	friend void PrintPerosn2<>(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 test01(){
	Person<string, int>p("zbc", 12);
	PrintPerosn(p);
}
void test02(){
	Person<string, int>p2("年轻人", 18);
	PrintPerosn2(p2);
}
int main(void){
	test01();
	system("pause");
	return 0;
}

一般，写全局函数配合类内实现即可，类外实现过于复杂。

2.9 类模板特化

有些时候，我们需要对特殊的类型做特殊的处理，就需要判断如果是某个类型的时候，走另外的分支（模板）。
在这种情况下，就需要为该特定类型定义专用化模板，即模板特化。这样编译器遇到该类型就会实例化特化的模板定义。

#include<iostream>
using namespace std;

// @file:模板特化
// @author:IdealSanX_T
// @date:2024/6/20 15:40:24
// @brief:

template<class T>
class Ctest {
public:
	T value;
	Ctest(T v) :value{v} {
		cout << "泛型模板" << endl;
	}
};

// 模板特化，接收int类型时使用此模板
template<>
class Ctest<int> {
public:
	int value;
	Ctest(int v) :value{ v } {
		cout << "特化模板" << endl;
	}
};

int main() {
	Ctest<string> test01{"ss"};
	Ctest<int> test02{ 1 };
	system("pause");
	return 0;
}

三、 函数模板和函数重载

区别

  • 用处：
    • 函数重载用于定义功能相似的同名函数，提高函数的易用性；
    • 函数模板则用于为实现逻辑一样只是参数类型不同的一类函数提供统一的模板，提高函数编写的效率
  • 形参列表：
    • 函数重载要求参数个数或类型不同；
    • 函数模板则要求参数个数必须一样

联系

  • 函数模板也可以进行重载
FFFfengZiz.
关注
  • 28
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
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++ 模板
weixin_44235615的博客
03-19 1753
基本概念：模板就是建立通用的模具，大大提高代码的复用性。 特点： 模板不可以直接使用，只是一个框架 模板的通用并不是万能的 泛型编程主要利用的思想就是模板 模板分为函数模板和类模板 总结： 函数模板利用关键字template 使用函数模板有两种方式：自动类型推导、显示指定类型 模板的目的是为了提高复用性，将类型参数化 注意事项： 自动类型推导，必须推导出一致的数据类型T，才可以使用 模板必须要确定出T的数据类型，才可以使用 普通函数与函数模板的区别： 普通函数调用时可以发生自动类型转换
C++模板
weixin_63246738的博客
05-19 5954
c++的模板
c++模板函数
weixin_48984572的博客
09-06 2584
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 1596
【优点】1、 模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生2、 增强了代码的灵活性【缺陷】1、 模板会导致代码膨胀问题，也会导致编译时间变长2、 出现模板编译错误时，错误信息非常凌乱，不易定位错误。
C++模板(函数模板/类模板)
DR5200的博客
10-05 5273
文章目录一.泛型编程二.函数模板 一.泛型编程 在引入泛型编程之前,我们先来看这样一个问题,怎么做到实现一个通用的交换函数呢? 在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 1467
模板特化 在学习模板的时候我们用模板来解决了一个add模板函数，实现不同类型的传参相加，实践证明，模板函数比普通函数好用。那么现在如果我们要新增一个需求，就是如果传入的是两个string类型的参数，我们不要简单的拼接，我们要在两个字符串之间添加一个空格，显然模板函数已经无法满足我们的要求，解决方法就是使用模板特化，简单说就是模板的一个特殊化，当传参为两个string类型的时候，不调用模板函数，而是调用特化模板函数，传入其它类型的时候，仍然使用模板函数，如下示例： template &l...
C++模板函数
weixin_45738899的博客
12-06 2万+
模板函数与类模板1.模板函数1.模板函数的声明与定义2.模板函数的调用显式类型调用自动推导3.模板函数的底层实现 1.模板函数 1.模板函数的声明与定义 C++提供了模板(template)编程的概念。所谓模板，实际上是建立一个通用函数或类，其类内部的类型和函数的形参类型不具体指定，用一个虚拟的类型来代表。这种通用的方式称为模板。模板是泛型编程的基础,泛型编程即以一种独立于任何特定类型的方式编写代码。 简单来说，就是我们提供一个抽象的函数，并不具体指定其中数据的类型，而是某个虚拟类型代替。只提供基本的功
C++模板详解
qq_52905520的博客
10-21 1万+
C++模板详解
《 C++模板》和《C++模板元编程》两本
03-20
C++模板是C++语言中的一个强大特性，它允许程序员创建泛型代码，即能够处理多种数据类型的代码。模板在C++中分为两种主要类型：函数模板和类模板。函数模板用于定义可以接受不同类型参数的函数，而类模板用于创建...
C++模板与STL库介绍
03-18
C++模板和STL库是C++编程语言中的两个核心特性，它们极大地提高了代码的复用性和效率。本文将深入探讨这两个主题，并提供丰富的实践应用示例。 首先，我们来理解C++模板。模板是C++的一个强大工具，它允许程序员...
C++ 模板函数
01-07
C++模板的使用可以提升代码的通用性、可移植性。方便通用库的开发。 与模板有关的关键字有两个： template 定义模板所用到的关键字。 typename 类型的名字，比如int，double，可以使用类类型，struck类型等。也可以...
【C++】STL—vector的使用
2301_77112794的博客
09-04 715
本文介绍了vector重点函数接口的使用
C语言 | Leetcode C语言题解之第389题找不同
m0_59237910的博客
09-07 516
C语言 | Leetcode C语言题解之第389题找不同
C语言作用域
天道酬勤
09-07 965
作用域 (scope) 是描述程序可以访问标识符的区域。块是一对花括号 {} 括起来的区域 或 函数体内任意复合语句定义范围内的区域。定义在块中的变量具有块作用域。块作用域的变量的可见范围从定义处开始到该块定义范围的末尾为止。函数作用域是在整个函数体内可见的意思，在 C 程序中，函数形参和 goto 语句的标签具有函数作用域，在整个函数体内可见。在所有函数外定义的变量具有全局作用域，在整个程序都可见。在数据类型前加 static 关键字定义的全局变量具有文件作用域。
QWidget(c++)嵌入window环境的exe
sunflower_2020的博客
09-05 292
QWidget(c++)嵌入window环境的exe
C语言——strcpy、sprintf与memcpy
最新发布
鲸落博客
09-09 1072
该函数和printf()函数有很多相似之处，例如printf()将不同类型的数据格式化到终端，而sprintf()函数是将不同类型的数据格式化到字符串中。另外，和strcpy()函数一样，该函数也不会对目标缓冲区进行检查，容易造成溢出。它是一种非常通用的内存复制函数，不仅限于复制字符串，还可以复制任何类型的内存块。3. 未定义行为：程序可能会继续运行，但结果不可预测，可能会输出错误的结果或导致其他未预料的行为。如果memcpy复制字符串，要复制的字节数超过原内存块本身的内存数，会怎么样？
C++模板元编程深度探索
"C++模板元编程相关学习资料" C++模板元编程是一种在编译时进行计算和代码生成的技术，它是C++语言的一个强大特性，允许程序员利用模板机制来实现泛型编程的更高层次抽象。模板元编程通常涉及到类型级别的计算，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值