C++中的模板

最新推荐文章于 2024-08-04 14:16:25 发布
最新推荐文章于 2024-08-04 14:16:25 发布
阅读量538 收藏 5
点赞数
分类专栏： C++ 文章标签： 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lao_tan/article/details/125427233
版权
本文探讨了函数模板如何创建通用函数，类模板如何定义数据类型参数化，包括类型推导、默认参数、成员函数实现和友元处理。通过实例展示了不同类型数据的交换、排序和类模板的使用方法，以及类模板继承和友元的注意事项。
摘要由CSDN通过智能技术生成

模版就是建立一个通用的模具，大大提高复用性。

1、函数模板

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

目的：将类型参数化。

语法：

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

template：声明创建模板

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

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

普通函数调用时可以发生自动类型转换（隐式类型转换）。

模板并不是万能的。

例一：交换两个数据，根据类型分别写对应函数。

#include<iostream>
using namespace std;
//交换两个整形数据
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;
}
void test01()
{
	int a = 10;
	int b = 20;
	swapInt(a, b);
	cout << a << endl;
	cout << b << endl;
	double c = 1.1;
	double d = 2.2;
	swapDouble(c,d);
	cout << c << endl;
	cout << d << endl;
}
int main()
{
	test01();
}

例二：使用函数模板完成任意类型数据的相加

#include<iostream>
using namespace std;
//交换两个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);
	//2、显示指定类型
	//Myswap<int>(a,b);
	cout << a << endl;
	cout << b << endl;
}
int main()
{
	test01();
}

注意：模板必须确定T的数据类型，才可以使用。且数据类型必须一致。例如上例中将整形和字符型进行交换，数据类型不同将会报错。

例：利用函数模板对不同数据类型的数组进行从大到小的选择排序。

#include<iostream>
using namespace std;
//交换两个T型数据

template<typename T>
void mySwap(T&a,T&b)
{
	T temp = a;
	a = b;
	b = temp;
}
template<typename T>
void printArr(T arr[], int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
}

template<typename 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++)
		{
			if (arr[max] < arr[j])
			{
				max = j;
			}
		}
		if (max != i)
		{
			mySwap(arr[max], arr[i]);
		}
	}
}
void test01()
{
	char charArr[] = "badcfe"; //测试char数组
	int num = sizeof(charArr) / sizeof(char);
	Mysort(charArr, num);
	printArr(charArr, num);
}
int main()
{
	test01();
}

2、类模板

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

语法：

Template<typename T>

类

template<typename T> //声明创建模板

template：声明创建模板

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_Name = name;
		this->m_Age = age;
	}
	void showPerson()
	{
		cout << "Name: " << this->m_Name << endl;
		cout << "Age: " << this->m_Age << endl;
	}
	NameType m_Name;
	AgeType m_Age;
};

void test01()
{
	Person<string, int> p1("wxq", 29);
	//<>模版的参数列表
	p1.showPerson();
}
int main()
{
	test01();
}

2.1、类模板和函数模板的区别

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

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


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 << endl;
		cout << "Age: " << this->m_Age << endl;
	}
	NameType m_Name;
	AgeType m_Age;
};
//类模板没有自动推导类型
void test01()
{
	//Person p1("wxq", 29); 
	//错误，无法用自动类型推导
	
	Person<string, int> p2("wxq", 29);
	//只能用显示指定类型
	p2.showPerson();
}
int main()
{
	test01();
}

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 << "Name: " << this->m_Name << endl;
		cout << "Age: " << this->m_Age << endl;
	}
	NameType m_Name;
	AgeType m_Age;
};
//类模板在模板参数列表中可以有默认参数
void test01()
{
	Person<string> p2("wxq", 29);
	//只能用显示指定类型
	p2.showPerson();
}
int main()
{
	test01();
}

类模板中的成员函数

类模板中的成员函数和普通类中的成员函数的创建时机是不同的：普通类的成员函数一开始就可以创建成员函数；类模板中的成员函数在调用时创建。

#include<iostream>
#include"string"
using namespace std;
class Person1
{
public:
	void showPerson1()
	{
		cout << "Person1 shows!" << endl;
	}
};
class Person2
{
public:
	void showPerson2()
	{
		cout << "Person2 shows!" << endl;
	}
};
template<class T>
class Person
{
public:
	T obj;
	void func1()
	{
		obj.showPerson1();
	}
	void func2()
	{
		obj.showPerson2();
	}
};

void test01()
{
	Person<Person1> m;
	m.func1();
	//m.func2();  //报错，因为m中无showPerson2函数
}
int main()
{
	test01();
}

类模板对象做函数参数

类模板实例出的对象作为函数的实参，一共有三种传入方式：

1、指定类型的传入：直接显示对象的数据类型（主要使用）

2、参数模板化：将对象中的参数变为模板进行传递（类模板配合函数模版）

3、整个类模板化：将这个对象类型模板化进行传递

#include<iostream>
#include"string"
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 << "name is " <<m_Name<< endl;
		cout << "age is " << m_Age<<endl;
	}
	T1 m_Name;
	T2 m_Age;
};
//1、指定传入类型
void printPerson1(Person<string,int>& p)
{
	p.showPerson();
}
void test01()
{
	Person<string, int> p("Wang", 100);
	printPerson1(p);
}
//2、将参数模板化
template<class T1, class T2>
void printPerson2(Person<T1, T2>& p)
{
	p.showPerson();
}
void test02()
{
	Person<string, int> p("Li", 90);
	printPerson2(p);
}
//3、整个类模板化
template<class T>
void printPerson3(T& p)
{
	p.showPerson();
}
void test03()
{
	Person<string, int> p("Zhang", 80);
	printPerson3(p);
}
int main()
{
	test01();
	test02();
	test03();
}

类模板与继承

需要注意几个点：

1、当子类继承的父类是一个类模板时，子类在声明时需要指定父类中T的类型；如果不指定，编译器则无法给子类分配内存。

2、如果想灵活指定父类中的T的类型，子类也需要变为类模板。

如果父类是类模板，子类在继承时需要指定父类中的数据类型。

#include<iostream>
#include"string"
using namespace std;
template<class T>
class Base
{
	T m;
};
//class  Son :public Base  //错误，必须知道父类的T的数据类型，才能继承给子类
//class  Son :public Base<int> //正确，但是子类只能为int
template<class T1, class T2>
class  Son :public Base<T2>
{
	T1 obj;
};
void test01()
{
	Son<int,char> s1;  //int传给T1，char传给T2，父类中的T也为char
}
int main()
{
	test01();
}

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

#include<iostream>
#include"string"
using namespace std;
template<class T1, class T2>
class Person
{
public:
	Person(T1 name, T2 age);
	void show();
	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>::show()
{
	cout << "Name is " << this->m_Name << endl;
	cout << "Age is " << this->m_Age << endl;
}
void test01()
{
	Person<string, int> p("Wang", 100);
	p.show();
}
int main()
{
	test01();
}

类模板分文件编写

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

方法：

1、直接包含CPP源文件

2、将声明个实现写在同一个文件中，并更改后缀名为.hpp。hpp是一个约定的概念，表示的就是类模板的分文件编写。（用的多）

方法1：

Person.h

Person.cpp

Main.cpp

#pragma once

#include<iostream>

#include"string"

using namespace std;

template<class T1, class T2>

class Person

{

public:

         Person(T1 name, T2 age);

         void show();

         T1 m_Name;

         T2 m_Age;

};

#include"Person.h"

//构造函数的类外实现

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>::show()

{

         cout << "Name is " << this->m_Name << endl;

         cout << "Age is " << this->m_Age << endl;

}

#include"Person.cpp"  //包含的是cpp，不是h

//第二种解决方法是把.h和.cpp文件写在一起，将后缀名改为.hpp文件

void test01()

{

         Person<string, int> p("Wang", 100);

         p.show();

}

int main()

{

         test01();

}

方法2

Person.hpp

Main.cpp

#pragma once

#include<iostream>

#include"string"

using namespace std;

template<class T1, class T2>

class Person

{

public:

         Person(T1 name, T2 age);

         void show();

         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>::show()

{

         cout << "Name is " << this->m_Name << endl;

         cout << "Age is " << this->m_Age << endl;

}

#include"Person.hpp"  //包含的是cpp，不是h

//第二种解决方法是把.h和.cpp文件写在一起，将后缀名改为.hpp文件

void test01()

{

         Person<string, int> p("Wang", 100);

         p.show();

}

int main()

{

         test01();

}

类模板与友元

主要包括友元函数的类内实现和类外实现。类内直接声明友元即可，类外实现则需要提前让编译器指导全局函数的存在。

case 1:友元函数在类内实现

#include<iostream>
#include"string"
using namespace std;
template<class T1,class T2>
class Person
{
public:
	Person(T1 name, T2 age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	friend void show(Person<T1, T2> p)
	{
		cout << "Name is " <<p.m_Name << endl;
		cout << "Age is " << p.m_Age << endl;
	}
private:
	T1 m_Name;
	T2 m_Age;
};
//1、全局函数在类内实现
void test01()
{
	Person<string, int> p("Wang", 100);
	show(p);
}
int main()
{
	test01();
}

case 2:友元函数在类外实现

#include<iostream>
#include"string"
using namespace std;
//提前让编译器知道person类的存在
template<class T1, class T2>
class Person;

//2、全局函数类外实现，先让编译器知道有个类外函数的存在
template<class T1, class T2>
void show(Person<T1, T2> p)
{
	cout << "Name is " << p.m_Name << endl;
	cout << "Age is " << p.m_Age << endl;
}

template<class T1,class T2>
class Person
{
public:
	Person(T1 name, T2 age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	//加空模板的参数列表 <>
	//如果全局函数是类外实现，需要让编译器提前知道这个函数的存在
	friend void show<>(Person<T1, T2> p);
private:
	T1 m_Name;
	T2 m_Age;
};

void test01()
{
	Person<string, int> p("Wang", 100);
	show(p);
}
int main()
{
	test01();
}

类外实现比较复杂，首先需要让编译器知道有一个全局函数的存在，由于用到了person，要先让编译器知道person类存在，person类又是一个类模板，因此还得声明类模板。

如无特殊需求，尽量类内实现。

Lao_tan
关注
专栏目录
C++中模板类型推断
zys15195875600的博客
02-14 1298
类型推导：类型推导规则 问题1：我们为什么要掌握类型推导规则？ 答：只有当我们熟悉类型推导的规则，才能让我们的代码更加的灵活，通用性好。 类型推导的作用：代码更加的灵活，通用性好 类型推导的适用场景： 函数模板、类模板(万能引用) auto decltype decltype(auto) 函数模板的类型推导规则： 知识点1：万能引用（未定义引用）（只限定函数模板，在...
C++模板
天道酬勤
06-03 2707
模板是C++中泛型编程的基础，一个模板就是一个创建类或函数的公式，当使用模板类型时，编译器会生成特定的类或函数，这个过程发生在编译时。 模板定义 模板定义以关键字template开始，后跟以个模板参数列表，这是一个逗号分隔的一个或多个模板参数的列表，用尖括号括起来。 template<typename T,typename M> 模板参数表示在类或函数定义中用到的类型或值，在使用模板...
C++模板（template）
TU^的博客
08-04 1957
【优点】1、 模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生2、 增强了代码的灵活性【缺陷】1、 模板会导致代码膨胀问题，也会导致编译时间变长2、 出现模板编译错误时，错误信息非常凌乱，不易定位错误。
c++之模板
qq_51789922的博客
06-25 451
模板
【C++】模板详解
2301_77954967的博客
07-27 2448
C++模板作为C++语言的强大特性，具有不可忽视的重要性和显著的优势。其重要性体现在，极大地提高了代码的复用性，减少了重复代码的编写；通过编译时的类型检查保障了代码的类型安全；为泛型编程、容器类、算法库等提供了坚实的基础，使代码更具通用性和可扩展性。本篇博文对C++模板做了一个较为详细的介绍，不知道对你有没有帮助呢觉得博主写得还不错的三连支持下吧！会继续努力的~
C++中模板的思维导图
最新发布
09-22
C++中模板的思维导图
浅析C++中模板的那点事
09-05
C++中的模板可分为函数模板和类模板，而把函数模板的具体化称为模板函数，把类模板的具体化成为模板类。下面让我们分别看看什么是函数模板和类模板吧
c++文件模板 c++文件模板
02-24
c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件...
C++中的模板及其使用
weixin_69874091的博客
09-06 1668
模板定义并不是真正的定义了一个函数或者类，而是编译器根据程序员缩写的模板和形参来自己写出一个对应版本的定义，这个过程叫做模板实例化。一个模板函数都会经历二次编译，第一次编译是在实例化之前，检查模板代码自身是否正确，第二编译是在实例化时，把调用者提供的类型参数带入模板中再次检查模板代码。编译器也可以自动帮助我们推断参数时什么类型，从而不用显示的调用模板函数，对于上面的compare函数，我们可以这样调用，前提时保证参数类型相同。模板类的类型参数不能隐式打断，也就是不能自动实例化，必须显式的指定类型参数。
C++中的模板类
热门推荐
qq_39645539的博客
07-11 1万+
什么是模板类：C++发展到一定层次后，必然有部分代码存在仅传参的数据类型不同而内容一致的情况。因此，C++为解决此类场景，特推出模板类的使用。模板类是一种泛型技术，即与数据类型无关的通用程序设计技术。可以使我们设计出独立于数据类型的程序。模板类本身不占空间，当编译器执行到模板参数的调用时，当在程序中赋予具体的数据类型后并调用时则占用空间。常见的模板包含函数模板与类模板。模板的声明中class含义同typenamec，class并不是表明后续的类型名是一个类，而表示后续是一个通用的类型说明符。一、函数模板函数
C++模板（类模板）
weixin_62142545的博客
08-21 1913
C++类模板基础语法知识
C++类模板
weixin_45738899的博客
12-06 5323
C++类模板1.上期内容2.类模板1.在类内部定义与声明2.在类外部定义成员函数3.类模板的继承 1.上期内容 2.类模板 类模板是为了减少重复工作量而出现的一种进制，当一个类的功能类似只是类型相同时，一个通用的类模板可以根据使用者的需要而生成具体类型的类，从而减少功能重复的代码。 C++在STL中大量使用了类模板，很多迭代器与算法的实现都离不开泛型编程与类模板的支持。所以掌握类模板的基本使用是很重要的。 1.在类内部定义与声明 #include <iostream> #include <
【C++】类模板
debug...
07-24 1957
C++类模板
（B站黑马C++）模板
IT OR 考公？
07-07 1548
记录代码，只用于复习
C++的各种模板
weixin_44220762的博客
11-10 303
C++的各种模板 优先队列 #include 默认定义—例如priority_queue d; priority_queue<vector, less > pq1;默认递增排序，头大尾小 priority_queue<vector, greater > pq1;递减排序，头效尾大 ...
C++模板详解（函数模板、类模板）
bang___bang_的博客
05-13 2737
本文详细讲解模板：函数模板，类模板，模板特化，非特性模板参数，详细得当适合初学者学习。
C++中模板技术的实现机理
05-27
C++中的模板是一种泛型编程技术，它允许我们编写通用的代码，可以应用于不同的数据类型。模板技术的实现机理是通过编译器在编译时根据模板参数生成具体的代码。 在C++中，我们可以使用类模板和函数模板两种方式来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值