C++入门day14（模板）

最新推荐文章于 2024-06-01 17:50:53 发布

闲看庭花

最新推荐文章于 2024-06-01 17:50:53 发布

阅读量174

点赞数

分类专栏： C++入门文章标签： c++

本文链接：https://blog.csdn.net/weixin_45982321/article/details/114679771

版权

C++入门专栏收录该内容

23 篇文章 0 订阅

订阅专栏

文章目录

模板

[从现在起，就是 C++ 提高编程的内容了-- 泛型编程和 STL技术]

模板

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

例如生活中的模板：一寸照片模板，PPT模板
优点：通用性很强
缺点：不能直接用

函数模板

C++ 另一种编程思想称为泛型编程，主要利用的技术就是模板
C++ 提高两种模板机制：函数模板和类模板

函数模板语法

函数模板作用：

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

语法：

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

解释：

template  -- 声明创建模板
typename  -- 表明其后面的符合是一种数据类型，可以用 class 代替
T  -- 通用的数据类型，名称可以替换，通常为大写字母

使用函数模板的2种方法：
1、自动类型推导：编译器干的，不用程序员干活
2、显示指定类型：程序员指定一下

函数模板的注意事项

注意事项：

自动类型推导，必须推导出一致的数据类型 T ，才可以使用
模板必须要确定出 T 的数据类型，才可以使用
一个cpp里可以写好几个模板，模板名 T 可以一样，但是下面必须接定义

#include <iostream>
using namespace std; 
// 函数模板语法 
template <typename T>
void mySwap(T &a, T &b)
{
	T temp = a;
	a = b;
	b = temp;
}
// 假设 char c = "c";
// mySwap(a,c); 会报错，因为 int 和 char 是不同的数据类型
// 一旦设置了 模板，一定要写出 T 的数据类型 
void test()
{
	int a = 10;
	int b = 20;
	mySwap(a,b);  // 自动类型推导 
	cout<<a<<"\t"<<b<<endl;
	
	double c = 3.14;
	double d = 5.67;
	mySwap(c,d);  // 自动类型推导 
	cout<<c<<"\t"<<d<<endl;
	
	bool e = true;
	bool f = false;
	mySwap<bool>(e,f);  // 显示指定类型 
	cout<<e<<"\t"<<f<<endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

运行结果：

20      10
5.67    3.14
0       1
请按任意键继续. . .

函数模板案例

案例描述：
利用函数模板封装一个排序的函数，可以对不同数据类型数组进行排序
排序规则从大到小，排序算法为选择排序
分别利用 char 数组和 int 数组进行测试

#include <iostream>
using namespace std;
// 函数模板案例 -- 数组排序 

// 交换函数的模板 
template <typename S>
void mySwap(S &a, S &b)
{
	S temp=a;
	a=b;
	b=temp;
}
// 选择排序的模板 
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++)
		{
			// 认定的最大值比遍历出的数值要小，说明 j 下标的元素才是真正的最大值 
			if(arr[max]<arr[j])
			{
				max=j;
			}
		}
		if(max!=i)
		{
			// 交换 max 和 i 元素
			mySwap(arr[max], arr[i]); 
		}
	}
	
}
// 提供打印数组的模板（一个cpp里可以写好几个模板，模板名 T 可以一样，但是下面必须接定义） 
template <typename T>
void printArray(T arr[], int len)
{
	for (int i=0;i<len;i++)
	{
		cout<<arr[i]<<" ";
	}
	cout<<endl;
} 

void test01()
{
	char charArr[] = "nhdkwkbwk";
	int num = sizeof(charArr) / sizeof(char);
	mySort(charArr,num); 
	printArray(charArr,num);
} 
void test02()
{
	int intArr[] = {5,2,1,9,3,2,7,8,6,4,2,0,9};
	int num2 = sizeof(intArr) / sizeof(int);
	mySort(intArr,num2); 
	printArray(intArr,num2);
}
int main()
{
	test01();
	test02();
	system("pause");
	return 0;
}

运行结果：

w w n k k k h d b 
9 9 8 7 6 5 4 3 2 2 2 1 0
请按任意键继续. . .

普通函数与函数模板区别

区别：

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

#include <iostream>
using namespace std;
// 普通函数与函数模板区别
// 普通函数
int myAdd01(int a,int b)
{
	return a + b;
} 
// 函数模板 
template <typename T>
T myAdd02(T a,T b)
{
	return a + b;
} 

void test01()
{
	int a = 10;
	int b = 20;
	char c = 'c';
	cout<<myAdd01(a,b)<<"\t"<<myAdd01(a,c)<<endl;
	
	cout<<"显示指定类型："<<myAdd02<int>(a,c)<<endl;
} 

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

运行结果：

30      109
显示指定类型：109
请按任意键继续. . .

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

规则：

如果函数模板和普通函数都可以实现，优先调用普通函数
可以通过空模板参数列表来强制调用函数模板
函数模板也可以发生重载
如果函数模板可以产生更好的匹配，优先调用函数模板

总结：如果提供了函数模板，就尽量不要再提供普通函数，否则容易产生二义性

#include <iostream>
using namespace std;
// 普通函数与函数模板的调用规则 
void myPrint(int a,int b)
{
	cout<<"-- 普通函数 --"<<endl;
} 
// 函数模板 
template <typename T>
void myPrint(T a,T b)
{
	cout<<"-- 函数模板 --"<<endl;
} 
// 函数模板重载
template <typename 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,100);
} 
void test02()
{
	int a = 10;
	int b = 20;
	myPrint<>(a,b);  // 空模板强制调用模板函数 
}
int main()
{
	test01();
	test02();
	system("pause");
	return 0;
}

运行结果：

-- 普通函数 --
-- 函数模板重载--
-- 函数模板 --
请按任意键继续. . .

模板的局限性

总结：
利用具体化的模板，可以解决自定义类型的通用化
学习模板并不是为了写模板，而是在 STL 能够运用系统提供的模板

#include <iostream>
using namespace std;
#include <string>
// 模板的局限性
// 对比两个数据是否相等的函数模板
template<typename T>
bool myCompare(T &a,T &b)
{
	if(a==b)
	{
		return true;
	}
	else
	{
		return false;
	}
} 
// 自定义一个类 
class Person
{
	public:
		Person(string name, int age)
		{
			this->m_Name=name;
			this->m_Age=age;
		}
	string m_Name;
	int m_Age;
};

// Person 和 Person 怎么对比呢？
// 方法一：运算符重载
// 方法二： 
template<>bool myCompare(Person &p1, Person &p2)
{
	if(p1.m_Name==p2.m_Name && p1.m_Age==p2.m_Age)
	{
		return true;
	}
	else
	{
		return false;
	}
}

void test()
{
	Person p1("Tom",10);
	Person p2("Tom",10);
	
	bool ret = myCompare(p1,p2);
	if(ret)
	{
		cout<<"p1 == p2"<<endl;
	}
	else
	{
		cout<<"p1 != p2"<<endl;
	}
}

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

运行结果：

p1 == p2
请按任意键继续. . .

类模板

类模板语法

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

语法：

template <typename T>
类

类模板与函数模板的区别

区别：
类模板没有自动类型推导的使用方式
类模板在模板参数列表中可以有默认参数

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

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

#include <iostream>
using namespace std;
#include <string>
// 类模板
template <typename NameType, typename AgeType=int>
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 test()
{
	Person <string> p1 ("孙悟空", 999);
	p1.showPerson();
}
int main()
{
	test();
	system("pause");
	return 0;
}

运行结果：

孙悟空  999
请按任意键继续. . .

类模板对象做函数参数

类模板实例化出来的对象，向函数传参的方式有三种：

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

#include <iostream>
using namespace std;
#include <string>
#include <typeinfo>
// 三种传递方式
template <typename T1, typename T2>
class Person
{
	public:
		Person(T1 name, T2 age)
		{
			this->m_Name=name;
			this->m_Age=age;
		}
		void showPerson()
		{
			cout<<this->m_Name<<"\t"<<this->m_Age<<endl;
		}
		T1 m_Name;
		T2 m_Age;
};
// 指定传入的类型
void printPerson1(Person<string,int>&p)
{
	p.showPerson();
}
void test01()
{
	Person<string,int> p ("孙悟空", 2000);
	printPerson1(p);
}
// 参数模板化
template <typename T1, typename 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> p ("猪八戒", 1900);
	printPerson2(p);
}
// 整个类模板化
template <typename T>
void printPerson3(T &p)
{
	p.showPerson();
	cout<<"T1 的类型为："<<typeid(T).name()<<endl;
}
void test03()
{
	Person<string,int> p ("沙和尚", 1890);
	printPerson3(p);
}
int main()
{
	test01();
	cout<<"----------"<<endl;
	test02();
	cout<<"----------"<<endl;
	test03();
	
	system("pause");
	return 0;
}

运行结果：

孙悟空  2000
----------
猪八戒  1900
T1 的类型为：Ss
T2 的类型为：i
----------
沙和尚  1890
T1 的类型为：6PersonISsiE
请按任意键继续. . .

类模板与继承

当类模板碰到继承时，需要注意：

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

类模板成员函数类外实现

#include <iostream>
using namespace std;
#include <string> 
// 类模板成员函数类外实现
template <typename T1, typename T2>
class Person
{
	public:
		Person(T1 name, T2 age);
//		{
//			this->m_Name=name;
//			this->m_Age=age;
//		}
		void showPerson();
//		{
//			cout<<this->m_Name<<"\t"<<this->m_Age<<endl;
//		}
		T1 m_Name;
		T2 m_Age;
}; 
// 构造函数的类外实现
template <typename T1, typename T2>
Person<T1,T2>::Person(T1 name, T2 age)
{
	this->m_Name=name;
	this->m_Age=age;
}
// 成员函数的类外实现
template <typename T1, typename T2>
void Person<T1,T2>::showPerson()
{
	cout<<this->m_Name<<"\t"<<this->m_Age<<endl;
}
void test()
{
	Person<string,int> P ("Tom", 25);
	P.showPerson();
}
int main()
{
	test();
	system("pause");
	return 0;
}

运行结果：

Tom     25
请按任意键继续. . .

类模板分文件编写

问题：
类模板中成员函数创建时机是在调用阶段，导致分文件编写时链接不到
解决：
方法一：main里直接包含类模板.cpp 源文件，比如 #include “person.cpp”，而person.cpp里已经包含了 person.h
方法二：将声明(.h)和实现(.cpp)写到同一个文件中(.hpp)

类模板与友元

全局函数类内实现 – 直接在类内声明友元即可
全局函数类外实现 – 需要提前让编译器知道全局函数的存在
（把全局函数放在最上面，其相关的内容声明一下（给一份存在感）。总之，十分复杂，跳过吧）

类模板案例

案例描述：实现一个通用的数组类

可以对内置数据类型以及自定义数据类型的数据进行存储
将数组中的数据存储到堆区
构造函数中可以传入数组的容量
提供对应的拷贝构造函数以及 operator= 防止浅拷贝问题
提供尾插法和尾删法对数组中的数据进行增加和删除
可以通过下标的方式访问数组中的元素
可以获取数组中当前元素个数和数组的容量

类模板案例

闲看庭花

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
C++入门day14（模板）

文章目录模板函数模板函数模板语法函数模板的注意事项函数模板案例普通函数与函数模板区别普通函数与函数模板的调用规则模板的局限性类模板类模板语法类模板与函数模板的区别类模板中成员函数的创建时机类模板对象做函数参数类模板与继承类模板成员函数类外实现类模板分文件编写类模板与友元类模板案例[从现在起，就是 C++ 提高编程的内容了-- 泛型编程和 STL技术]模板模板的概念模板就是建立通用的模具，可以大大提高复用性例如生活中的模板：一寸照片模板，PPT模板优点：通用性很强缺点：不能直接用函数模板
复制链接

扫一扫