• C++ 学习（16）模板 - 函数模板 与 类模板

    1、模板

    C++的其中一种编程思想为泛型编程，主要利用的技术就模板，模板的特点：

    • 模板不可以直接使用，它只是一个框架
    • 模板的通用并不是万能的

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

    2、函数模板

    2.1、基本语法

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

    语法： 

    template

    函数声明或定义

    解释：

    template    声明创建模板

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

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

    1. #include 
    2. using namespace std;
    3.  
    4. //函数模板
    5. template<typename T>
    6. void mySwap(T& a, T& b)
    7. {
    8. 	T tmp = a;
    9. 	a = b;
    10. 	b = tmp;
    11. }
    12.  
    13. int main()
    14. {
    15. 	int a = 5;
    16. 	int b = 8;
    17.  
    18. 	cout << "交换前： a = " << a << "，b = " << b << endl;
    19.  
    20. 	//1、自动类型推导
    21. 	mySwap(a, b);
    22. 	cout << "自动类型推导 - 交换后： a = " << a << "，b = " << b << endl;
    23.  
    24. 	//2、显式指定类型
    25. 	mySwap<int>(a, b);
    26. 	cout << "显式指定类型 - 再次交换后： a = " << a << "，b = " << b << endl;
    27.  
    28. 	system("pause");
    29.  
    30. 	return 0;
    31. }

     输出结果

    交换前： a = 5，b = 8
    自动类型推导 - 交换后： a = 8，b = 5
    显式指定类型 - 再次交换后： a = 5，b = 8

    2.2、注意事项

    • 自动类型推导，必须推导出一致的数据类型T才可以使用
    • 模板必须要确定出T的数据类型 ，才可以使用
    1. #include 
    2. using namespace std;
    3.  
    4. //函数模板
    5. template<typename T>
    6. void mySwap(T& a, T& b)
    7. {
    8. 	T tmp = a;
    9. 	a = b;
    10. 	b = tmp;
    11. }
    12.  
    13. //函数模板， 也可以使用calss代替typename
    14. template<class T>
    15. void f1()
    16. {
    17. 	cout << "函数没有使用模板中的类型T" << endl;
    18. }
    19.  
    20. int main()
    21. {
    22. 	int a = 5;
    23. 	int b = 8;
    24. 	char c = 'a';
    25.  
    26. 	//1、自动类型推导 - 必须推导出一致的数据类型T才可以使用
    27. 	mySwap(a, b);
    28. 	// mySwap(a, c);_//报错：没有与参数列表匹配的函数模板 mySwap 的实例参数类型为(int, char)
    29.  
    30.  
    31. 	//2、模板必须要确定出T的数据类型 ，才可以使用
    32. 	//f1();//报错：没有与参数列表匹配的函数模板 f1 的实例
    33. 	f1<int>();
    34. 	f1<char>();
    35.  
    36. 	system("pause");
    37.  
    38. 	return 0;
    39. }

    2.3、普通函数与函数模板区别

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

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

    1. #include 
    2. using namespace std;
    3.  
    4. //普通函数 - 两数相加
    5. int add(int a, int b)
    6. {
    7. 	return a + b;
    8. }
    9.  
    10. //函数模板 - 两数相加
    11. template<typename T>
    12. T add2(T a, T b)
    13. {
    14. 	return a + b;
    15. }
    16.  
    17. int main()
    18. {
    19. 	//函数模板 - 普通函数与函数模板区别
    20. 	int a = 1;
    21. 	char c = 'a';
    22.  
    23. 	//普通函数调用 - 参数可以自动类型转换（隐式类型转换）
    24. 	cout << "普通函数调用，结果 = " << add(a, c) << endl;
    25.  
    26. 	//函数模板调用 - 自动类型推导，不会发生隐式类型转换
    27. 	//add2(a, c); //报错：没有与参数列表匹配的函数模板add2实例参数类型为：(int,char)
    28.  
    29. 	//函数模板调用 - 显式指定类型，可以发生隐式类型转换
    30. 	cout << "函数模板调用 - 显式指定类型，结果 = " << add2<int>(a, c) << endl;
    31.  
    32. 	system("pause");
    33.  
    34. 	return 0;
    35. }

    输出结果

    普通函数调用，结果 = 98
    函数模板调用 - 显式指定类型，结果 = 98 

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

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

    如果提供了函数模板，最好就不要提供普通函数，否则容易出现二义性，实际开发中避免同时出现。

    1. #include 
    2. using namespace std;
    3.  
    4. //普通函数
    5. void print(int a, int b)
    6. {
    7. 	cout << "普通函数 - 参数 a = " << a << ", b = " << b << endl;
    8. }
    9.  
    10. //函数模板
    11. template<typename T>
    12. void print(T a, T b)
    13. {
    14. 	cout << "函数模板 - 参数 a = " << a << ", b = " << b << endl;
    15. }
    16.  
    17. //函数模板重载
    18. template<typename T>
    19. void print(T a, T b, T c)
    20. {
    21. 	cout << "函数模板重载 - 参数 a = " << a << ", b = " << b << ", c = " << c << endl;
    22. }
    23.  
    24. int main()
    25. {
    26. 	//函数模板 - 普通函数与函数模板调用规则 
    27. 	/*
    28. 		1、如果函数模板和普通函数都可以实现，优先调用普通函数
    29. 		2、可以通过空模板参数列表来强制调用函数模板
    30. 		3、函数模板也可以发生重载
    31. 		4、如果函数模板可以产生更好的匹配，优先调用函数模板
    32. 	*/
    33. 	int a = 1;
    34. 	int b = 8;
    35. 	//1、如果函数模板和普通函数都可以实现，优先调用普通函数
    36. 	print(a, b);
    37.  
    38. 	//2、可以通过空模板参数列表来强制调用函数模板
    39. 	print<>(a, b);
    40.  
    41. 	//3、函数模板也可以发生重载
    42. 	print(a, b, 20);
    43.  
    44. 	//4、如果函数模板可以产生更好的匹配，优先调用函数模板
    45. 	print('a', 'c');
    46.  
    47.  
    48. 	system("pause");
    49.  
    50. 	return 0;
    51. }

    输出结果

    普通函数 - 参数 a = 1, b = 8
    函数模板 - 参数 a = 1, b = 8
    函数模板重载 - 参数 a = 1, b = 8, c = 20
    函数模板 - 参数 a = a, b = c

    2.5、模板的局限性

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

    利用具体化的模板，可以解决自定义类型的通用化，具体化模板优先调用

    学习模板并不是为了写模板，而是在STL能够运用系统提供的模板

    1. #include 
    2. using namespace std;
    3.  
    4. //函数模板 - 比较
    5. template<typename T>
    6. void compare(T& a, T& b)
    7. {
    8. 	if (a == b)
    9. 	{
    10. 		cout << "相等" << endl;
    11. 	}
    12. 	else
    13. 	{
    14. 		cout << "不相等" << endl;
    15. 	}
    16. }
    17.  
    18. class Person
    19. {
    20. public:
    21. 	string name;
    22. 	int age;
    23.  
    24. 	Person(string _name, int _age): name(_name), age(_age){}
    25. };
    26.  
    27. //如果想让类对象进行比较，需要利用具体化模板，具体化模板优先调用
    28. template<> void compare(Person& p1, Person& p2)
    29. {
    30. 	if (p1.name == p2.name && p1.age == p2.age)
    31. 	{
    32. 		cout << "相等" << endl;
    33. 	}
    34. 	else
    35. 	{
    36. 		cout << "不相等" << endl;
    37. 	}
    38. }
    39.  
    40. int main()
    41. {
    42. 	//函数模板 - 局限性
    43. 	//如果想让类对象进行比较，需要利用具体化模板
    44. 	Person p1("Tracy", 20);
    45. 	Person p2("Timo", 20);
    46.  
    47. 	compare(p1, p2); //若没用具体化模板，编译时报错：二进制"==":"T"不定义该运算符到预定义运算符可接收的类型转换
    48.  
    49. 	system("pause");
    50.  
    51. 	return 0;
    52. }

     输出结果 

    不相等

    3、类模板

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

    3.1 基本语法

    语法：

    template

    类

    解释：

    template  声明创建模板

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

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

    1. #include 
    2. #include 
    3. using namespace std;
    4.  
    5. //类模板
    6. template<class NameType, class AgeType>
    7. class Person
    8. {
    9. public:
    10. 	NameType name;
    11. 	AgeType age;
    12.  
    13. 	Person(NameType _name, AgeType _age) : name(_name), age(_age) {}
    14.  
    15. 	void print()
    16. 	{
    17. 		cout << "类模板成员属性值 name = " << name << ", age = " << age << endl;
    18. 	}
    19. };
    20.  
    21. int main()
    22. {
    23. 	//类模板 - 基本语法
    24.  
    25. 	//类模板实例化对象 - 显式指定类型
    26. 	Personint> p1("Tracy", 20);
    27. 	p1.print();
    28.  
    29. 	system("pause");
    30.  
    31. 	return 0;
    32. }

    输出结果

    类模板成员属性值 name = Tracy, age = 20

    3.2、类模板与函数模板区别

    • 类模板没有自动类型推导，只能使用显式指定类型
    • 类模板在模板参数列表中可以有默认参数 
    1. #include 
    2. #include 
    3. using namespace std;
    4.  
    5. //类模板
    6. //类模板在模板参数列表中可以有默认参数 
    7. template<class NameType, class AgeType = int>
    8. class Person
    9. {
    10. public:
    11. 	NameType name;
    12. 	AgeType age;
    13.  
    14. 	Person(NameType _name, AgeType _age): name(_name), age(_age) {}
    15.  
    16. 	void print()
    17. 	{
    18. 		cout << "类模板成员属性值 name = " << name << ", age = " << age << endl;
    19. 	}
    20. };
    21.  
    22. int main()
    23. {
    24. 	//类模板 - 类模板与函数模板区别
    25. 	/*
    26. 		1、类模板没有自动类型推导，只能使用显式指定类型
    27. 		2、类模板在模板参数列表中可以有默认参数 
    28. 	*/
    29.  
    30. 	//1、类模板没有自动类型推导，只能使用显式指定类型
    31. 	//Person p1("Tracy", 20); //没有自动类型推导，报错：缺少类模板 Person的参数列表
    32. 	Personint> p2("Tracy", 20); //显式指定类型
    33. 	p2.print();
    34.  
    35. 	//2、类模板在模板参数列表中可以有默认参数 
    36. 	Person p3("Timo", 30);
    37. 	p3.print();
    38.  
    39. 	system("pause");
    40.  
    41. 	return 0;
    42. }

    输出结果

    类模板成员属性值 name = Tracy, age = 20
    类模板成员属性值 name = Timo, age = 30

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

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

    1. #include 
    2. #include 
    3. using namespace std;
    4.  
    5. //类模板
    6. class Person1
    7. {
    8. public:
    9. 	void print1()
    10. 	{
    11. 		cout << "类模板中的成员函数" << endl;
    12. 	}
    13. };
    14.  
    15. //普通类
    16. class Person2
    17. {
    18. public:
    19. 	void print2()
    20. 	{
    21. 		cout << "普通类中的成员函数" << endl;
    22. 	}
    23. };
    24.  
    25. //类模板 - 在调用成员函数时才会创建成员函数
    26. template<class T>
    27. class TestClass
    28. {
    29. public:
    30. 	T obj;
    31.  
    32. 	//调用类模板中的成员函数
    33. 	void f1()
    34. 	{
    35. 		obj.print1();
    36. 	}
    37.  
    38. 	//调用普通模板中的成员函数
    39. 	void f2()
    40. 	{
    41. 		obj.print2();
    42. 	}
    43. };
    44.  
    45. int main()
    46. {
    47. 	//类模板 - 类模板中成员函数创建时机：在调用成员函数时才创建
    48. 	TestClass t1;
    49. 	t1.f1();
    50. 	//t1.f2();  //编译时报错：print2不是Person1的成员
    51.  
    52. 	TestClass t2;
    53. 	//t2.f1();  //编译时报错：print不是Person2的成员
    54. 	t2.f2();
    55.  
    56. 	system("pause");
    57.  
    58. 	return 0;
    59. }

    输出结果

    类模板中的成员函数
    普通类中的成员函数

    3.4、类模板对象作函数参数

    类模板对象作函数参数有三种传入方式

    1. 指定传入类型：直接显式对象的数据类型（建议使用）
    2. 参数模板化，将对象中的参数变为模板进行传递
    3. 整个类模板化：将这个对象类型模板化进行传递
    1. #include 
    2. #include 
    3. using namespace std;
    4.  
    5. //类模板
    6. template<class NameType, class AgeType>
    7. class Person
    8. {
    9. public:
    10. 	NameType name;
    11. 	AgeType age;
    12.  
    13. 	Person(NameType _name, AgeType _age): name(_name), age(_age) {}
    14.  
    15. 	void print()
    16. 	{
    17. 		cout << "类模板成员属性值 name = " << name << ", age = " << age << endl;
    18. 	}
    19. };
    20.  
    21. //1、指定传入类型：直接显式对象的数据类型（建议使用）
    22. void show1(Personint>& p)
    23. {
    24. 	p.print();
    25. }
    26.  
    27. //2、参数模板化，将对象中的参数变为模板进行传递
    28. template<typename T1, typename T2>
    29. void show2(Person& p)
    30. {
    31. 	p.print();
    32. 	cout << "参数模板化，T1的类型 = " << typeid(T1).name() << endl;
    33. 	cout << "参数模板化，T2的类型 = " << typeid(T2).name() << endl;
    34. }
    35.  
    36. //3、整个类模板化：将这个对象类型模板化进行传递
    37. template<typename T>
    38. void show3(T& p)
    39. {
    40. 	p.print();
    41. 	cout << "整个类模板化，T的类型 = " << typeid(T).name() << endl;
    42. }
    43.  
    44. int main()
    45. {
    46. 	//类模板 - 类模板对象作函数参数
    47. 	/*
    48. 	* 三种方式：
    49. 		1、指定传入类型：直接显式对象的数据类型（建议使用）
    50. 		2、参数模板化，将对象中的参数变为模板进行传递
    51. 		3、整个类模板化：将这个对象类型模板化进行传递
    52. 	*/
    53. 	Personint> p1("Tracy", 20);
    54. 	show1(p1);
    55. 	show2(p1);
    56. 	show3(p1);
    57.  
    58. 	system("pause");
    59.  
    60. 	return 0;
    61. }

    输出结果

    类模板成员属性值 name = Tracy, age = 20
    类模板成员属性值 name = Tracy, age = 20
    参数模板化，T1的类型 = class std::basic_string,class std::allocator >
    参数模板化，T2的类型 = int
    类模板成员属性值 name = Tracy, age = 20
    整个类模板化，T的类型 = class Person,class std::allocator >,int>

    3.5、类模板与继承

    当子类继承的父类是一个类模板时：

    • 子类在声明的时候要指定出父类中T的类型，如果不指定，编译器无法给子类分配内存；
    • 如果想灵活指定父类中T的类型，子类也需要变为类模板
    1. #include 
    2. #include 
    3. using namespace std;
    4.  
    5. //类模板 - 父类
    6. template<class NameType, class AgeType>
    7. class Person
    8. {
    9. public:
    10. 	NameType name;
    11. 	AgeType age;
    12. };
    13.  
    14. //子类 - 子类在声明的时候要指定出父类中T的类型
    15. // 1、在父类后加指定类型
    16. //class Sub : public Person  //不指定父类中T的类型，报错：缺少类模板Person的参数列表
    17. class Sub : public Personint>
    18. {
    19. };
    20.  
    21. //2、子类变为类模板
    22. template<class T1, class T2, class T3>
    23. class Sub2 : public Person
    24. {
    25. public:
    26. 	T3 obj;
    27.  
    28. 	Sub2()
    29. 	{
    30. 		cout << "T1的类型：" << typeid(T1).name() << endl;
    31. 		cout << "T2的类型：" << typeid(T2).name() << endl;
    32. 		cout << "T3的类型：" << typeid(T3).name() << endl;
    33. 	}
    34. };
    35.  
    36.  
    37. int main()
    38. {
    39. 	//类模板 - 类模板与继承
    40. 	Sub s1;
    41.  
    42. 	Sub2int, char> s2;
    43.  
    44. 	system("pause");
    45.  
    46. 	return 0;
    47. }

    输出结果

    T1的类型：class std::basic_string,class std::allocator >
    T2的类型：int
    T3的类型：char

    3.6、类模板成员函数类外实现 

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

    1. #include 
    2. #include 
    3. using namespace std;
    4.  
    5. //类模板
    6. template<class NameType, class AgeType>
    7. class Person
    8. {
    9. public:
    10. 	NameType name;
    11. 	AgeType age;
    12.  
    13. 	//构造函数
    14. 	Person(NameType _name, AgeType _age);
    15.  
    16. 	//成员函数
    17. 	void print();
    18. };
    19.  
    20. //构造函数类外实现
    21. template<typename NameType, typename AgeType>
    22. Person::Person(NameType _name, AgeType _age)
    23. {
    24. 	name = _name;
    25. 	age = _age;
    26. }
    27.  
    28. //成员函数类外实现
    29. template<typename NameType, typename AgeType>
    30. void Person::print()
    31. {
    32. 	cout << "类模板成员属性值 name = " << name << ", age = " << age << endl;
    33. }
    34.  
    35. int main()
    36. {
    37. 	//类模板 - 类模板成员函数类外实现
    38. 	Personint> p1("Tracy", 20);
    39. 	p1.print();
    40.  
    41. 	system("pause");
    42.  
    43. 	return 0;
    44. }

    输出结果

    类模板成员属性值 name = Tracy, age = 20 

    3.7、类模板分文件编写

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

    解决（二种解决方案）

    1. 直接包含.cpp源文件
    2. 将声明和实现写在同一个文件中，并更改文件后缀名为.hpp，hpp是编写的名称，并不是强制的

    3.7.1、直接包含.cpp源文件

    （1）创建头文件person.h

    1. #pragma once
    2. #include 
    3. #include 
    4. using namespace std;
    5.  
    6. //类模板
    7. template<class NameType, class AgeType>
    8. class Person
    9. {
    10. public:
    11. 	NameType name;
    12. 	AgeType age;
    13.  
    14. 	//构造函数
    15. 	Person(NameType _name, AgeType _age);
    16.  
    17. 	//成员函数
    18. 	void print();
    19. };

    （2）创建源文件person.cpp

    1. #include "person.h"
    2.  
    3. //构造函数类外实现
    4. template
    5. Person::Person(NameType _name, AgeType _age)
    6. {
    7. 	name = _name;
    8. 	age = _age;
    9. }
    10.  
    11. //成员函数类外实现
    12. template
    13. void Person::print()
    14. {
    15. 	cout << "类模板成员属性值 name = " << name << ", age = " << age << endl;
    16. }

     （3）主函数文件

    1. #include 
    2. #include 
    3. using namespace std;
    4. //直接包含.cpp源文件
    5. #include "person.cpp"
    6.  
    7. int main()
    8. {
    9. 	//类模板 - 类模板分文件编写 - 直接包含.cpp源文件
    10. 	Personint> p1("Tracy", 20);
    11. 	p1.print();
    12.  
    13. 	system("pause");
    14.  
    15. 	return 0;
    16. }

    输出结果

    类模板成员属性值 name = Tracy, age = 20

    3.7.2、声明和实现写到同一个文件后缀名.hpp 

    （1）创建头文件person.hpp

    1. #pragma once
    2. #include 
    3. #include 
    4. using namespace std;
    5.  
    6. //类模板
    7. template<class NameType, class AgeType>
    8. class Person
    9. {
    10. public:
    11. 	NameType name;
    12. 	AgeType age;
    13.  
    14. 	//构造函数
    15. 	Person(NameType _name, AgeType _age);
    16.  
    17. 	//成员函数
    18. 	void print();
    19. };
    20.  
    21. //构造函数类外实现
    22. template<typename NameType, typename AgeType>
    23. Person::Person(NameType _name, AgeType _age)
    24. {
    25. 	name = _name;
    26. 	age = _age;
    27. }
    28.  
    29. //成员函数类外实现
    30. template<typename NameType, typename AgeType>
    31. void Person::print()
    32. {
    33. 	cout << "类模板成员属性值 name = " << name << ", age = " << age << endl;
    34. }

    （2）主函数

    1. #include 
    2. #include 
    3. using namespace std;
    4. //声明和实现写到同一个文件后缀名.hpp
    5. #include "person.hpp"
    6.  
    7. int main()
    8. {
    9. 	//类模板 - 类模板分文件编写 - 声明和实现写到同一个文件后缀名.hpp
    10. 	Personint> p1("Tracy", 20);
    11. 	p1.print();
    12.  
    13. 	system("pause");
    14.  
    15. 	return 0;
    16. }

    输出结果

    类模板成员属性值 name = Tracy, age = 20

    3.8、类模板与友元

    • 全局函数类内实现：直接在类内声明友元即可
    • 全局函数类外实现：需要提前让编译器知道全局函数的存在，类内声明时需要空模板参数列表

    1. #include 
    2. #include 
    3. using namespace std;
    4.  
    5. //提前声明全局函数类外实现中使用到的类模板
    6. template<class T1, class T2>
    7. class Person;
    8.  
    9. //2、全局函数类外实现：需要提前让编译器知道全局函数的存在
    10. template<class T1, class T2>
    11. void print2(Person& p)
    12. {
    13. 	cout << "全局函数类外实现， name = " << p.name << ", age = " << p.age << endl;
    14. }
    15.  
    16. //类模板
    17. template<class T1, class T2>
    18. class Person
    19. {
    20. 	//1、全局函数类内实现：直接在类内声明友元即可
    21. 	friend void print1(Person& p)
    22. 	{
    23. 		cout << "全局函数类内实现， name = " << p.name << ", age = " << p.age << endl;
    24. 	}
    25.  
    26. 	//2、全局函数类内声明类外实现 - 需要使用空模板参数列表
    27. 	friend void print2<>(Person& p);
    28.  
    29. private:
    30. 	T1 name;
    31. 	T2 age;
    32.  
    33. public:
    34. 	Person(T1 _name, T2 _age) : name(_name), age(_age) {}
    35. };
    36.  
    37. int main()
    38. {
    39. 	//类模板 - 类模板与友元
    40. 	/*
    41. 		1、全局函数类内实现：直接在类内声明友元即可
    42. 		2、全局函数类外实现：需要提前让编译器知道全局函数的存在
    43. 	*/	
    44. 	Personint> p1("Tracy", 20);
    45. 	print1(p1);
    46. 	print2(p1);
    47.  
    48. 	system("pause");
    49.  
    50. 	return 0;
    51. }

    输出结果

    全局函数类内实现， name = Tracy, age = 20
    全局函数类外实现， name = Tracy, age = 20

  • 相关阅读:
    SPI总线协议
    FPGA帧差算法实现图像识别跟踪，Verilog代码讲解全网最细，提供两套工程源码
    【pwn】2022 祥云杯 部分wp
    c语言-数据结构-堆
    9.java项目-尚医通（9）
    Uni-app 苹果应用打包与上线指南
    WIN11系统设置重启与睡眠唤醒后自动拨号
    使用 vue-element-admin 开发后台管理系统【安装】
    唯品会三年，我只做了5件事，如今跳槽天猫拿下offer（Java岗）
    xv6---Lab2: system calls
  • 原文地址：https://blog.csdn.net/ling1998/article/details/126047180