• C++模板 —— 万字带你了解C++模板（蓝桥杯算法比赛必备知识STL基础）

    目录

     

    模板的概念

    函数模板 

             函数模板的作用：

    函数模板的语法：

    解释：

    示例：

    总结：

    函数模板注意事项

    注意事项：

    示例：

    总结：

     函数模板案例

    案例描述：

    示例：

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

    总结：

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

    调用规则如下：

    示例：

    模板的局限性（函数模板的第二种实现）

    类模板

    类模板基础语法 

    语法：

    解释：

    示例：

    类模板与函数模板的区别

    问题引出（一）

    问题引出（二）

    类模板中成员函数调用时机

    添加测试代码：

    总结：

    类模板对象做函数参数

    类模板与继承

    示例：

    类模板成员函数类外实现

    类模板与友元

    模板的概念

    模板就是我们建立的通用的模具，用来提高代码的复用性。

    生活中最经典的就是证件照模板了

     上面模板的特点：

    • 模板不可以直接使用，它只是一个框架（不可能拿一个照片模板交给领导或者老师吧，得有你自己的“信息”）

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

    函数模板 

    •  C++的另一种编程思想——泛型编程，利用的主要就是模板。
    • C++提供两种模板机制:函数模板和类模板

    函数模板的作用：

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

    函数模板的语法：

    1. //template告诉编译器，要开始写模板了
    2. //typename或者class都可以
    3. //T是虚拟类型
    4. template<typename T>    
    5. 函数声明或定义

    解释：

    template --- 声明创建模板

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

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

    示例：

    1. //交换整型函数
    2. void swapInt(int &a,int &b){
    3.     int temp = 0;
    4.     a = b;
    5.     b = temp;
    6. }
    7.  
    8. //交换浮点型函数
    9. void swapDouble(double &a,double &b){
    10.     double temp = a;
    11.     a = b;
    12.     b = temp;
    13. }
    14.  
    15. //利用函数模板提供通用的交换函数
    16. template
    17. void mySwap(T &A,T &b)
    18. {
    19. 	T temp = a;
    20. 	a = b;
    21. 	b = temp;
    22. }
    23.  
    24. void test01()
    25. {
    26. 	int a = 10;
    27. 	int b = 20;
    28. 	
    29. 	//swapInt(a, b);
    30.  
    31. 	//利用模板实现交换
    32. 	//1、自动类型推导
    33. 	mySwap(a, b);
    34.  
    35. 	//2、显示指定类型
    36. 	mySwap<int>(a, b);
    37.  
    38. 	cout << "a = " << a << endl;
    39. 	cout << "b = " << b << endl;
    40.  
    41. }
    42.  
    43. int main() {
    44.  
    45. 	test01();
    46.  
    47. 	system("pause");
    48.  
    49. 	return 0;
    50. }

    总结：

    • 函数模板利用关键字 template

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

    • 模板的目的是为了提高复用性，将类型参数化

    函数模板注意事项

    注意事项：

    • 自动类型推导，必须推导出一致的数据类型T,才可以使用

    • 模板必须要确定出T的数据类型，才可以使用（函数中没有用到T的话，就只能自己写了）

    示例：

    1. //利用模板提供通用的交换函数
    2. template<class T>	//typename可以替换成class
    3. void mySwap(T& a, T& b)
    4. {
    5. 	T temp = a;
    6. 	a = b;
    7. 	b = temp;
    8. }
    9.  
    10.  
    11. // 1、自动类型推导，必须推导出一致的数据类型T,才可以使用
    12. void test01()
    13. {
    14. 	int a = 10;
    15. 	int b = 20;
    16. 	char c = 'c';
    17.  
    18. 	mySwap(a, b); // 正确，可以推导出一致的T
    19. 	//mySwap(a, c); // 错误，推导不出一致的T类型
    20. }
    21.  
    22.  
    23. // 2、模板必须要确定出T的数据类型，才可以使用
    24. template<class T>
    25. void func()
    26. {
    27. 	cout << "func 调用" << endl;
    28. }
    29.  
    30. void test02()
    31. {
    32.     //因为函数体中没有用到T，所以自动类型推导也不知道怎么推导了
    33. 	//func(); //错误，模板不能独立使用，必须确定出T的类型
    34. 	func<int>(); //利用显示指定类型的方式，给T一个类型，才可以使用该模板
    35. }
    36.  
    37. int main() {
    38.  
    39. 	test01();
    40. 	test02();
    41.  
    42. 	system("pause");
    43.  
    44. 	return 0;
    45. }

    总结：

    • 使用模板时必须确定出通用数据类型T，并且能够推导出一致的类型

     函数模板案例

    案例描述：

    • 利用函数模板封装一个排序的函数，可以对不同数据类型数组进行排序

    • 排序规则从大到小，排序算法为选择排序

    • 分别利用char数组和int数组进行测试

    示例：

    1. //交换函数模板
    2. template<class T>
    3. void mySwap(T& a, T& b)
    4. {
    5. 	T temp = a;
    6. 	a = b;
    7. 	b = temp;
    8. }
    9.  
    10. //排序算法
    11. template<class T>
    12. void mySort(T arr[] , int len) {
    13. 	for (int i = 0; i < len ; i++) {
    14. 		int max = i;	//先随便找一个设为最大值
    15. 		for (int j = i + 1; j < len; j++)
    16. 		{
    17. 			if (arr[max] < arr[j])
    18. 				//更新下标
    19. 				max = j;
    20. 		}
    21. 		if (max != i)
    22. 		{
    23. 			//交换max和i下标的元素
    24. 			mySwap(arr[max],arr[i]);
    25. 		}
    26. 	}
    27. }
    28.  
    29. //提供打印数组模板
    30. template<class T>
    31. void printArray(T arr[], int len)
    32. {
    33. 	for (int i = 0; i < len; i++)
    34. 	{
    35. 		cout << arr[i] << " ";
    36. 	}
    37. 	cout << endl;
    38. }
    39.  
    40. void test01()
    41. {
    42. 	//测试char数组
    43. 	char charArr[] = "bcfac";
    44. 	int num = sizeof(charArr) / sizeof(char);
    45. 	mySort(charArr, num);
    46. 	printArray(charArr , num);
    47. }
    48.  
    49. void test02()
    50. {
    51. 	//测试int数组
    52. 	int intArr[] = { 7, 5, 8, 1, 3, 9, 2, 4, 6 };
    53. 	int num = sizeof(intArr) / sizeof(int);
    54. 	mySort(intArr, num);
    55. 	printArray(intArr, num);
    56. }
    57.  
    58. int main() {
    59. 	test01();
    60.     test02();
    61.  
    62. 	system("pause");
    63. 	return 0;
    64. }

    如果上面这些程序你都实现了，那么你一定会对模板深有体会，模板大大提高了代码复用，需要熟练掌握

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

    普通函数与函数模板区别：

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

    • 函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换

    • 如果利用显示指定类型的方式，可以发生隐式类型转换

    1. //普通函数
    2. int myAdd01(int a, int b)
    3. {
    4. 	return a + b;
    5. }
    6.  
    7. //函数模板
    8. template<class T>
    9. T myAdd02(T a, T b)  
    10. {
    11. 	return a + b;
    12. }
    13.  
    14. //使用函数模板时，如果用自动类型推导，不会发生自动类型转换,即隐式类型转换
    15. void test01()
    16. {
    17. 	int a = 10;
    18. 	int b = 20;
    19. 	char c = 'c';
    20. 	
    21. 	cout << myAdd01(a, c) << endl; //正确，将char类型的'c'隐式转换为int类型  'c' 对应 ASCII码 99
    22.  
    23. 	//myAdd02(a, c); // 报错，使用自动类型推导时，不会发生隐式类型转换
    24.  
    25. 	myAdd02<int>(a, c); //正确，如果用显示指定类型，可以发生隐式类型转换
    26. }
    27.  
    28. int main() {
    29.  
    30. 	test01();
    31.  
    32. 	system("pause");
    33.  
    34. 	return 0;
    35. }

    总结：

            建议使用显示指定类型的方式，调用函数模板，因为可以自己确定通用类型T

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

    调用规则如下：

    1. 如果函数模板和普通函数都可以实现，优先调用普通函数

    2. 可以通过空模板参数列表来强制调用函数模板

    3. 函数模板也可以发生重载

    4. 如果函数模板可以产生更好的匹配,优先调用函数模板

    简单来说就是，函数模板里面，同名普通函数（只有声明也成立，只是会报错🤣）优先调用，同时函数模板也是可以重载的。

    示例：

    1. //普通函数与函数模板调用规则
    2. void myPrint(int a, int b)
    3. {
    4. 	cout << "调用的普通函数" << endl;
    5. }
    6.  
    7. template<typename T>
    8. void myPrint(T a, T b) 
    9. { 
    10. 	cout << "调用的模板" << endl;
    11.  
    12. //函数模板重载
    13. template<typename T>
    14. void myPrint(T a, T b, T c) 
    15. { 
    16. 	cout << "调用重载的模板" << endl; 
    17. }
    18.  
    19. void test01()
    20. {
    21. 	//1、如果函数模板和普通函数都可以实现，优先调用普通函数
    22. 	// 注意 如果告诉编译器  普通函数是有的，但只是声明没有实现，或者不在当前文件内实现，就会报错找不到
    23. 	int a = 10;
    24. 	int b = 20;
    25. 	myPrint(a, b); //调用普通函数
    26.  
    27. 	//2、可以通过空模板参数列表来强制调用函数模板
    28. 	myPrint<>(a, b); //调用函数模板
    29.  
    30. 	//3、函数模板也可以发生重载
    31. 	int c = 30;
    32. 	myPrint(a, b, c); //调用重载的函数模板
    33.  
    34. 	//4、 如果函数模板可以产生更好的匹配,优先调用函数模板
    35. 	char c1 = 'a';
    36. 	char c2 = 'b';
    37. 	myPrint(c1, c2); //调用函数模板
    38. }
    39.  
    40. int main() {
    41.  
    42. 	test01();
    43.  
    44. 	system("pause");
    45.  
    46. 	return 0;
    47. }

    其实我们提供函数模板了，就尽量不要再写普通函数了，不然会出现二义性的。

    模板的局限性（函数模板的第二种实现）

    函数模板并不是万能的，有些特定数据类型，需要用具体化方式做特殊实现。

    只有C++内置的数据类型可以直接使用前面学到的函数模板，自定义数据类型往往不能实现。

    1. #include
    2. using namespace std;
    3.  
    4. #include 
    5.  
    6. class Person
    7. {
    8. public:
    9. 	Person(string name, int age)
    10. 	{
    11. 		this->m_Name = name;
    12. 		this->m_Age = age;
    13. 	}
    14. 	string m_Name;
    15. 	int m_Age;
    16. };
    17.  
    18. //普通函数模板
    19. template<class T>
    20. bool myCompare(T& a, T& b)
    21. {
    22. 	if (a == b)
    23. 	{
    24. 		return true;
    25. 	}
    26. 	else
    27. 	{
    28. 		return false;
    29. 	}
    30. }
    31.  
    32.  
    33. //具体化，显示具体化的原型和定意思以template<>开头，并通过名称来指出类型
    34. //具体化优先于常规模板
    35. template<> bool myCompare(Person &p1, Person &p2)
    36. {
    37. 	if ( p1.m_Name  == p2.m_Name && p1.m_Age == p2.m_Age)
    38. 	{
    39. 		return true;
    40. 	}
    41. 	else
    42. 	{
    43. 		return false;
    44. 	}
    45. }
    46.  
    47. void test01()
    48. {
    49. 	int a = 10;
    50. 	int b = 20;
    51. 	//内置数据类型可以直接使用通用的函数模板
    52. 	bool ret = myCompare(a, b);
    53. 	if (ret)
    54. 	{
    55. 		cout << "a == b " << endl;
    56. 	}
    57. 	else
    58. 	{
    59. 		cout << "a != b " << endl;
    60. 	}
    61. }
    62.  
    63. void test02()
    64. {
    65. 	Person p1("Tom", 10);
    66. 	Person p2("Tom", 10);
    67. 	//自定义数据类型，不会调用普通的函数模板
    68. 	//可以创建具体化的Person数据类型的模板，用于特殊处理这个类型
    69. 	bool ret = myCompare(p1, p2);
    70. 	if (ret)
    71. 	{
    72. 		cout << "p1 == p2 " << endl;
    73. 	}
    74. 	else
    75. 	{
    76. 		cout << "p1 != p2 " << endl;
    77. 	}
    78. }
    79.  
    80. int main() {
    81.  
    82. 	test01();
    83.  
    84. 	test02();
    85.  
    86. 	system("pause");
    87.  
    88. 	return 0;
    89. }

    如上，利用具体化的模板，可以解决自定义类型的通用化。

    类模板

    类模板和函数模板的区别在于模板声明下面加的是类还是函数。

    类模板基础语法 

    语法：

    template
类

    解释：

    template --- 声明创建模板

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

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

    示例：

    1. //类模板
    2. // 流程：
    3. 	//class后面紧跟着的就是通用数据类型（如果成员中需要两个，就用逗号分隔写两个）
    4. 	//然后test01()中，在传入的时候，用模板参数列表给这里的两个..Type传值
    5. 	//后面的两个数据"猴哥",500；是给有参构造里面的name和age传值
    6. 	//最后调用showPerson输出
    7. template<class NameType,class AgeType>
    8. class Person
    9. {
    10. public:
    11. 	//写构造函数赋初值
    12. 	Person(NameType name, AgeType age)
    13. 	{
    14. 		this->m_Age = age;
    15. 		this->m_Name = name;
    16. 	}
    17.  
    18. 	void showPerson()
    19. 	{
    20. 		cout << "name:" << this->m_Name << "age:" << this->m_Age << endl;
    21. 	}
    22.  
    23. 	//两个类型不一样，需要两个模板数据类型
    24. 	NameType m_Name;
    25. 	AgeType m_Age;
    26. };
    27.  
    28. void test01()
    29. {	//将类型参数化
    30. 	Personint> p("猴哥",500);//后两个数据是实参，传给有参构造
    31. 	p.showPerson();
    32. }
    33.  
    34. int main()
    35. {
    36. 	test01();
    37. 	system("pause");
    38. 	return 0;
    39. }

    类模板与函数模板的区别

    问题引出（一）

    现在我们对上节示例稍微进行一下改动，把我们的显示类型声明给去掉。报错

    所以类模板是没有自动类型推导的。

    问题引出（二）

    看这里，我没有声明传入int型，但是也能实现，你猜是为什么？

     

     原来，我在前面加了点“小料”。

    我在声明模板的时候直接把AgeTyoe = int了，后面传进去的时候就不需要说是int型了。

    所以这就是类模板在模板参数列表中可以有默认参数。

    类模板中成员函数调用时机

    1. //类模板中成员函数创建时机
    2. //类模板中成员函数在调用时才去创建
    3. class Person1 {
    4. public:
    5. 	void showPerson1() {
    6. 		cout << "showPerson1函数调用" << endl;
    7. 	}
    8. };
    9. class Person2 {
    10. public:
    11. 	void showPerson2() {
    12. 		cout << "showPerson2函数调用" << endl;
    13. 	}
    14. };
    15.  
    16. //类模板
    17. template<class T>
    18. class MyClass
    19. {
    20. public:
    21. 	T obj;
    22.  
    23. 	//类模板中的成员函数
    24. 	void func1() {
    25. 		obj.showPerson1();
    26. 	}
    27. 	void func2() {
    28. 		obj.showPerson2();
    29. 	}
    30. };
    31.  
    32. int main()
    33. {
    34. 	system("pause");
    35. 	return 0;
    36. }

    这里没有调用类模板里面的成员函数，运行发现成功了。

    这两个成员函数fuc1，func2只要不调用就不会创建，因为编译器不知道类模板里面的obj是什么类型的。

    添加测试代码：

    1. void test01() {
    2. 	MyClassm;
    3. 	m.func1();
    4. 	m.func2();
    5. }

    调用测试运行结果：

    我们调用成员函数func1，func2，就可以确定obj就是Person1的数据类型，Person1没有showPerson2成员函数，所以会报错。

    总结：

            类模板中的成员函数并不是一开始就创建的，在调用时才去创建

    类模板对象做函数参数

    一共有三种传入方式：

    1. 指定传入的类型 --- 直接显示对象的数据类型

    2. 参数模板化 --- 将对象中的参数变为模板进行传递

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

    1. #include 
    2. //类模板
    3. template<class NameType, class AgeType = int> 
    4. class Person
    5. {
    6. public:
    7. 	Person(NameType name, AgeType age)
    8. 	{
    9. 		this->mName = name;
    10. 		this->mAge = age;
    11. 	}
    12. 	void showPerson()
    13. 	{
    14. 		cout << "name: " << this->mName << " age: " << this->mAge << endl;
    15. 	}
    16. public:
    17. 	NameType mName;
    18. 	AgeType mAge;
    19. };

    1. //1、指定传入的类型
    2. void printPerson1(Personint> &p) 
    3. {
    4. 	p.showPerson();
    5. }
    6. void test01()
    7. {
    8. 	Person int >p("孙悟空", 100);
    9. 	printPerson1(p);
    10. }
    1. //2、参数模板化
    2. template <class T1, class T2>
    3. void printPerson2(Person&p)
    4. {
    5. 	p.showPerson();
    6. 	cout << "T1的类型为： " << typeid(T1).name() << endl;
    7. 	cout << "T2的类型为： " << typeid(T2).name() << endl;
    8. }
    9. void test02()
    10. {
    11. 	Person int >p("猪八戒", 90);
    12. 	printPerson2(p);
    13. }
    1. //3、整个类模板化
    2. template<class T>
    3. void printPerson3(T & p)
    4. {
    5. 	cout << "T的类型为： " << typeid(T).name() << endl;
    6. 	p.showPerson();
    7.  
    8. }
    9. void test03()
    10. {
    11. 	Person int >p("唐僧", 30);
    12. 	printPerson3(p);
    13. }

    类模板与继承

    当类模板碰到继承时，需要注意一下几点：

    • 当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型

    • 如果不指定，编译器无法给子类分配内存

    • 如果想灵活指定出父类中T的类型，子类也需变为类模板

    示例：

    1. template<class T>
    2. class Base
    3. {
    4. 	T m;
    5. };
    6.  
    7. //class Son:public Base  //错误，c++编译需要给子类分配内存，必须知道父类中T的类型才可以向下继承
    8. class Son :public Base<int> //必须指定一个类型
    9. {
    10. };
    11. void test01()
    12. {
    13. 	Son c;
    14. }
    15.  
    16.  
    17. //类模板继承类模板 ,可以用T2指定父类中的T类型
    18. template<class T1, class T2>//想要灵活的指定父类中的T类型，子类也需要变成类模板
    19. class Son2 :public Base
    20. {
    21. public:
    22. 	Son2()
    23. 	{
    24. 		cout << typeid(T1).name() << endl;
    25. 		cout << typeid(T2).name() << endl;
    26. 	}
    27. };
    28.  
    29. void test02()
    30. {
    31. 	Son2<int, char> child1;
    32. }
    33.  
    34.  
    35. int main() {
    36.  
    37. 	test01();
    38.  
    39. 	test02();
    40.  
    41. 	system("pause");
    42.  
    43. 	return 0;
    44. }

    类模板成员函数类外实现

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

    1. #include 
    2.  
    3.  
    4. template<class T1, class T2>
    5. class Person {
    6. public:
    7. 	//成员函数类内声明
    8. 	Person(T1 name, T2 age);
    9. 	void showPerson();
    10.  
    11. public:
    12. 	T1 m_Name;
    13. 	T2 m_Age;
    14. };
    15.  
    16. //构造函数 类外实现
    17. template<class T1, class T2>
    18. Person::Person(T1 name, T2 age) {
    19. 	this->m_Name = name;
    20. 	this->m_Age = age;
    21. }
    22.  
    23. //成员函数 类外实现
    24. template<class T1, class T2>
    25. void Person::showPerson() {
    26. 	cout << "姓名: " << this->m_Name << " 年龄:" << this->m_Age << endl;
    27. }
    28.  
    29. void test01()
    30. {
    31. 	Personint> p("Tom", 20);
    32. 	p.showPerson();
    33. }
    34.  
    35. int main() {
    36.  
    37. 	test01();
    38.  
    39. 	system("pause");
    40.  
    41. 	return 0;
    42. }

    类模板与友元

    全局函数类内实现 - 直接在类内声明友元即可

    全局函数类外实现 - 需要提前让编译器知道全局函数的存在

    1. #include 
    2.  
    3. //2、全局函数配合友元  类外实现 - 先做函数模板声明，下方在做函数模板定义，在做友元
    4. template<class T1, class T2> class Person;
    5.  
    6. //如果声明了函数模板，可以将实现写到后面，否则需要将实现体写到类的前面让编译器提前看到
    7. //template void printPerson2(Person & p); 
    8.  
    9. template<class T1, class T2>
    10. void printPerson2(Person & p)
    11. {
    12. 	cout << "类外实现 ---- 姓名： " << p.m_Name << " 年龄：" << p.m_Age << endl;
    13. }
    14.  
    15. template<class T1, class T2>
    16. class Person
    17. {
    18. 	//1、全局函数配合友元   类内实现
    19. 	friend void printPerson(Person & p)
    20. 	{
    21. 		cout << "姓名： " << p.m_Name << " 年龄：" << p.m_Age << endl;
    22. 	}
    23.  
    24.  
    25. 	//全局函数配合友元  类外实现
    26. 	friend void printPerson2<>(Person & p);
    27.  
    28. public:
    29.  
    30. 	Person(T1 name, T2 age)
    31. 	{
    32. 		this->m_Name = name;
    33. 		this->m_Age = age;
    34. 	}
    35.  
    36.  
    37. private:
    38. 	T1 m_Name;
    39. 	T2 m_Age;
    40.  
    41. };
    42.  
    43. //1、全局函数在类内实现
    44. void test01()
    45. {
    46. 	Person int >p("Tom", 20);
    47. 	printPerson(p);
    48. }
    49.  
    50.  
    51. //2、全局函数在类外实现
    52. void test02()
    53. {
    54. 	Person int >p("Jerry", 30);
    55. 	printPerson2(p);
    56. }
    57.  
    58. int main() {
    59.  
    60. 	//test01();
    61.  
    62. 	test02();
    63.  
    64. 	system("pause");
    65.  
    66. 	return 0;
    67. }

  • 相关阅读:
    Kotlin 使用@BindingAdapter编译出错
    mac配置环境变量总结
    CockroachDB架构-分布式层
    【leetcode】最近最少使用缓存
    4、QtCharts 做心电图
    向量数据库是如何检索的？基于 Feder 的 HNSW 可视化实现
    SQL基础理论篇（六）：多表的连接方式
    Springboot踩坑-request body重复读问题
    索引特性之存列值优化sum avg
    Java：Java和C有什么区别?
  • 原文地址：https://blog.csdn.net/m0_62853489/article/details/127668750