• [黑马程序员C++笔记]P174-P184模板-类模板

    视频地址：黑马程序员匠心之作|C++教程从0到1入门编程,学习编程不再难_哔哩哔哩_bilibili

    目录

    P174模板-类模板基本语法

    P175模板-类模板和函数模板区别

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

    P177模板-类模板对象做函数参数

    P178模板-类模板与继承

    P179模板-类模板成员函数类外实现

    P180模板-类模板分文件编写

    P181模板-类模板与友元

    P182-P184模板-类模板案例

    P174模板-类模板基本语法

     类模板的作用：

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

    语法：

    1. template<typename T>
    2. 类

    解释：

    template --- 声明创建模板

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

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

    示例：

    1. using namespace std;
    2. #include<iostream>
    3. #include<string>
    4.  
    5. //类模板
    6. template <class NameType,class AgeType>
    7. class Person {
    8. public:
    9. 	Person(NameType name, AgeType age) {
    10. 		this->m_name = name;
    11. 		this->m_age = age;
    12. 	}
    13. 	void showPerson()
    14. 	{
    15. 		cout << "name: " << this->m_name << " age: " << this->m_age << endl;
    16. 	}
    17. public:
    18. 	NameType m_name;
    19. 	AgeType m_age;
    20. };
    21.  
    22. void test01() {
    23. 	Person <string, int > P1("孙悟空", 10000);
    24. 	P1.showPerson();
    25. }
    26.  
    27.  
    28. int main()
    29. {
    30. 	test01();
    31. 	system("pause");
    32. 	return 0;
    33. }

    结果：

    总结：类模板和函数模板语法相似，在声明模板template后面加类，此类称为类模板

    P175模板-类模板和函数模板区别

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

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

    2、类模板在模板参数列表中可以有默认参数

    示例：

    1. #include <string>
    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. };
    20.  
    21. //1、类模板没有自动类型推导的使用方式
    22. void test01()
    23. {
    24. 	// Person p("孙悟空", 1000); // 错误 类模板使用时候，不可以用自动类型推导
    25. 	Person <string ,int>p("孙悟空", 1000); //必须使用显示指定类型的方式，使用类模板
    26. 	p.showPerson();
    27. }
    28.  
    29. //2、类模板在模板参数列表中可以有默认参数
    30. void test02()
    31. {
    32. 	Person <string> p("猪八戒", 999); //类模板中的模板参数列表 可以指定默认参数
    33. 	p.showPerson();
    34. }
    35.  
    36. int main() {
    37.  
    38. 	test01();
    39.  
    40. 	test02();
    41.  
    42. 	system("pause");
    43.  
    44. 	return 0;
    45. }

    总结：

    • 类模板使用只能用显示指定类型方式

    • 类模板中的模板参数列表可以有默认参数

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

    总结：

    • 类模板使用只能用显示指定类型方式

    • 类模板中的模板参数列表可以有默认参数

    示例：

    1. class Person1
    2. {
    3. public:
    4. 	void showPerson1()
    5. 	{
    6. 		cout << "Person1 show" << endl;
    7. 	}
    8. };
    9.  
    10. class Person2
    11. {
    12. public:
    13. 	void showPerson2()
    14. 	{
    15. 		cout << "Person2 show" << endl;
    16. 	}
    17. };
    18.  
    19. template<class T>
    20. class MyClass
    21. {
    22. public:
    23. 	T obj;
    24.  
    25. 	//类模板中的成员函数，并不是一开始就创建的，而是在模板调用时再生成
    26.  
    27. 	void fun1() { obj.showPerson1(); }
    28. 	void fun2() { obj.showPerson2(); }
    29.  
    30. };
    31.  
    32. void test01()
    33. {
    34. 	MyClass<Person1> m;
    35. 	
    36. 	m.fun1();
    37.  
    38. 	//m.fun2();//编译会出错，说明函数调用才会去创建成员函数
    39. }
    40.  
    41. int main() {
    42.  
    43. 	test01();
    44.  
    45. 	system("pause");
    46.  
    47. 	return 0;
    48. }

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

    P177模板-类模板对象做函数参数

    学习目标：类模板实例化出的对象，向函数传参的方式

    一共有三种传入方式：

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

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

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

    示例：

    1. using namespace std;
    2. #include<iostream>
    3. #include<string>
    4.  
    5. //类模板对象做函数参数
    6. //1、
    7. template <class T1,class T2>
    8. class Person {
    9. public:
    10. 	Person(T1 name, T2 age) {
    11. 		this->m_Age = age;
    12. 		this->m_Name = name;
    13. 	}
    14. 	void showPerson() {
    15. 		cout << "name:" << this->m_Name << "age:" << this->m_Age << endl;
    16. 	}
    17. public:
    18. 	T1 m_Name;
    19. 	T2 m_Age;
    20. };
    21.  
    22. //1、指定传入类型
    23. void printPerson1(Person<string, int>& p) {
    24. 	p.showPerson();
    25. }
    26. void test01() {
    27. 	Person<string, int>p("孙悟空", 100);
    28. 	printPerson1(p);
    29. }
    30. //2、参数模板化
    31. template <class T1,class T2>
    32. void printPerson2(Person<T1, T2>& p) {
    33. 	p.showPerson();
    34. 	cout << "T1的类型为： " << typeid(T1).name() << endl;
    35. 	cout << "T2的类型为： " << typeid(T2).name() << endl;
    36. }
    37. void test02() {
    38. 	Person<string, int>p("猪八戒", 90);
    39. 	printPerson2(p);
    40. }
    41.  
    42. //3、整个类模板化
    43. template<class T>
    44. void printPerson3(T& p) {
    45. 	cout << "T的类型为： " << typeid(T).name() << endl;
    46. 	p.showPerson();
    47. }
    48. void test03()
    49. {
    50. 	Person <string, int >p("唐僧", 30);
    51. 	printPerson3(p);
    52. }
    53. int main()
    54. {
    55. 	test01();
    56. 	test02();
    57. 	test03();
    58. 	system("pause");
    59.  
    60. 	return 0;
    61. }

    结果：

     总结：

    • 通过类模板创建的对象，可以有三种方式向函数中进行传参

    • 使用比较广泛是第一种：指定传入的类型

    P178模板-类模板与继承

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

    • 当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中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. //类模板继承类模板 ,可以用T2指定父类中的T类型
    17. template<class T1, class T2>
    18. class Son2 :public Base<T2>
    19. {
    20. public:
    21. 	Son2()
    22. 	{
    23. 		cout << typeid(T1).name() << endl;
    24. 		cout << typeid(T2).name() << endl;
    25. 	}
    26. };
    27.  
    28. void test02()
    29. {
    30. 	Son2<int, char> child1;
    31. }
    32.  
    33.  
    34. int main() {
    35.  
    36. 	test01();
    37.  
    38. 	test02();
    39.  
    40. 	system("pause");
    41.  
    42. 	return 0;
    43. }

    总结：如果父类是类模板，子类需要指定出父类中T的数据类型

    P179模板-类模板成员函数类外实现

    示例：

    1. #include <string>
    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<T1, T2>::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<T1, T2>::showPerson() {
    26. 	cout << "姓名: " << this->m_Name << " 年龄:" << this->m_Age << endl;
    27. }
    28.  
    29. void test01()
    30. {
    31. 	Person<string, int> p("Tom", 20);
    32. 	p.showPerson();
    33. }
    34.  
    35. int main() {
    36.  
    37. 	test01();
    38.  
    39. 	system("pause");
    40.  
    41. 	return 0;
    42. }

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

    P180模板-类模板分文件编写

    问题：

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

    解决：

    • 解决方式1：直接包含.cpp源文件

    • 解决方式2：将声明和实现写到同一个文件中，并更改后缀名为.hpp，hpp是约定的名称，并不是强制

    示例：

    person.hpp中代码：

    1. #pragma once
    2. #include <iostream>
    3. using namespace std;
    4. #include <string>
    5.  
    6. template<class T1, class T2>
    7. class Person {
    8. public:
    9. 	Person(T1 name, T2 age);
    10. 	void showPerson();
    11. public:
    12. 	T1 m_Name;
    13. 	T2 m_Age;
    14. };
    15.  
    16. //构造函数 类外实现
    17. template<class T1, class T2>
    18. Person<T1, T2>::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<T1, T2>::showPerson() {
    26. 	cout << "姓名: " << this->m_Name << " 年龄:" << this->m_Age << endl;
    27. }

    类模板分文件编写.cpp中代码：
     

    1. #include<iostream>
    2. using namespace std;
    3.  
    4. //#include "person.h"
    5. #include "person.cpp" //解决方式1，包含cpp源文件
    6.  
    7. //解决方式2，将声明和实现写到一起，文件后缀名改为.hpp
    8. #include "person.hpp"
    9. void test01()
    10. {
    11. 	Person<string, int> p("Tom", 10);
    12. 	p.showPerson();
    13. }
    14.  
    15. int main() {
    16.  
    17. 	test01();
    18.  
    19. 	system("pause");
    20.  
    21. 	return 0;
    22. }

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

    P181模板-类模板与友元

    学习目标：

    • 掌握类模板配合友元函数的类内和类外实现

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

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

    1. #include <string>
    2.  
    3. //2、全局函数配合友元  类外实现 - 先做函数模板声明，下方在做函数模板定义，在做友元
    4. template<class T1, class T2> class Person;
    5.  
    6. //如果声明了函数模板，可以将实现写到后面，否则需要将实现体写到类的前面让编译器提前看到
    7. //template<class T1, class T2> void printPerson2(Person<T1, T2> & p); 
    8.  
    9. template<class T1, class T2>
    10. void printPerson2(Person<T1, T2> & 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<T1, T2> & p)
    20. 	{
    21. 		cout << "姓名： " << p.m_Name << " 年龄：" << p.m_Age << endl;
    22. 	}
    23.  
    24.  
    25. 	//全局函数配合友元  类外实现
    26. 	friend void printPerson2<>(Person<T1, T2> & 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 <string, int >p("Tom", 20);
    47. 	printPerson(p);
    48. }
    49.  
    50.  
    51. //2、全局函数在类外实现
    52. void test02()
    53. {
    54. 	Person <string, 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. }

    P182-P184模板-类模板案例

    案例描述: 实现一个通用的数组类，要求如下：

    • 可以对内置数据类型以及自定义数据类型的数据进行存储

    • 将数组中的数据存储到堆区

    • 构造函数中可以传入数组的容量

    • 提供对应的拷贝构造函数以及operator=防止浅拷贝问题

    • 提供尾插法和尾删法对数组中的数据进行增加和删除

    • 可以通过下标的方式访问数组中的元素

    • 可以获取数组中当前元素个数和数组的容量

    示例：

    myArray.hpp中代码

    1. #pragma once
    2. #include <iostream>
    3. using namespace std;
    4.  
    5. template<class T>
    6. class MyArray
    7. {
    8. public:
    9.     
    10. 	//构造函数
    11. 	MyArray(int capacity)
    12. 	{
    13. 		this->m_Capacity = capacity;
    14. 		this->m_Size = 0;
    15. 		pAddress = new T[this->m_Capacity];
    16. 	}
    17.  
    18. 	//拷贝构造
    19. 	MyArray(const MyArray & arr)
    20. 	{
    21. 		this->m_Capacity = arr.m_Capacity;
    22. 		this->m_Size = arr.m_Size;
    23. 		this->pAddress = new T[this->m_Capacity];
    24. 		for (int i = 0; i < this->m_Size; i++)
    25. 		{
    26. 			//如果T为对象，而且还包含指针，必须需要重载 = 操作符，因为这个等号不是 构造 而是赋值，
    27. 			// 普通类型可以直接= 但是指针类型需要深拷贝
    28. 			this->pAddress[i] = arr.pAddress[i];
    29. 		}
    30. 	}
    31.  
    32. 	//重载= 操作符  防止浅拷贝问题
    33. 	MyArray& operator=(const MyArray& myarray) {
    34.  
    35. 		if (this->pAddress != NULL) {
    36. 			delete[] this->pAddress;
    37. 			this->m_Capacity = 0;
    38. 			this->m_Size = 0;
    39. 		}
    40.  
    41. 		this->m_Capacity = myarray.m_Capacity;
    42. 		this->m_Size = myarray.m_Size;
    43. 		this->pAddress = new T[this->m_Capacity];
    44. 		for (int i = 0; i < this->m_Size; i++) {
    45. 			this->pAddress[i] = myarray[i];
    46. 		}
    47. 		return *this;
    48. 	}
    49.  
    50. 	//重载[] 操作符  arr[0]
    51. 	T& operator [](int index)
    52. 	{
    53. 		return this->pAddress[index]; //不考虑越界，用户自己去处理
    54. 	}
    55.  
    56. 	//尾插法
    57. 	void Push_back(const T & val)
    58. 	{
    59. 		if (this->m_Capacity == this->m_Size)
    60. 		{
    61. 			return;
    62. 		}
    63. 		this->pAddress[this->m_Size] = val;
    64. 		this->m_Size++;
    65. 	}
    66.  
    67. 	//尾删法
    68. 	void Pop_back()
    69. 	{
    70. 		if (this->m_Size == 0)
    71. 		{
    72. 			return;
    73. 		}
    74. 		this->m_Size--;
    75. 	}
    76.  
    77. 	//获取数组容量
    78. 	int getCapacity()
    79. 	{
    80. 		return this->m_Capacity;
    81. 	}
    82.  
    83. 	//获取数组大小
    84. 	int	getSize()
    85. 	{
    86. 		return this->m_Size;
    87. 	}
    88.  
    89.  
    90. 	//析构
    91. 	~MyArray()
    92. 	{
    93. 		if (this->pAddress != NULL)
    94. 		{
    95. 			delete[] this->pAddress;
    96. 			this->pAddress = NULL;
    97. 			this->m_Capacity = 0;
    98. 			this->m_Size = 0;
    99. 		}
    100. 	}
    101.  
    102. private:
    103. 	T * pAddress;  //指向一个堆空间，这个空间存储真正的数据
    104. 	int m_Capacity; //容量
    105. 	int m_Size;   // 大小
    106. };

    类模板案例—数组类封装.cpp中

    1. #include "myArray.hpp"
    2. #include <string>
    3.  
    4. void printIntArray(MyArray<int>& arr) {
    5. 	for (int i = 0; i < arr.getSize(); i++) {
    6. 		cout << arr[i] << " ";
    7. 	}
    8. 	cout << endl;
    9. }
    10.  
    11. //测试内置数据类型
    12. void test01()
    13. {
    14. 	MyArray<int> array1(10);
    15. 	for (int i = 0; i < 10; i++)
    16. 	{
    17. 		array1.Push_back(i);
    18. 	}
    19. 	cout << "array1打印输出：" << endl;
    20. 	printIntArray(array1);
    21. 	cout << "array1的大小：" << array1.getSize() << endl;
    22. 	cout << "array1的容量：" << array1.getCapacity() << endl;
    23.  
    24. 	cout << "--------------------------" << endl;
    25.  
    26. 	MyArray<int> array2(array1);
    27. 	array2.Pop_back();
    28. 	cout << "array2打印输出：" << endl;
    29. 	printIntArray(array2);
    30. 	cout << "array2的大小：" << array2.getSize() << endl;
    31. 	cout << "array2的容量：" << array2.getCapacity() << endl;
    32. }
    33.  
    34. //测试自定义数据类型
    35. class Person {
    36. public:
    37. 	Person() {} 
    38. 		Person(string name, int age) {
    39. 		this->m_Name = name;
    40. 		this->m_Age = age;
    41. 	}
    42. public:
    43. 	string m_Name;
    44. 	int m_Age;
    45. };
    46.  
    47. void printPersonArray(MyArray<Person>& personArr)
    48. {
    49. 	for (int i = 0; i < personArr.getSize(); i++) {
    50. 		cout << "姓名：" << personArr[i].m_Name << " 年龄： " << personArr[i].m_Age << endl;
    51. 	}
    52.  
    53. }
    54.  
    55. void test02()
    56. {
    57. 	//创建数组
    58. 	MyArray<Person> pArray(10);
    59. 	Person p1("孙悟空", 30);
    60. 	Person p2("韩信", 20);
    61. 	Person p3("妲己", 18);
    62. 	Person p4("王昭君", 15);
    63. 	Person p5("赵云", 24);
    64.  
    65. 	//插入数据
    66. 	pArray.Push_back(p1);
    67. 	pArray.Push_back(p2);
    68. 	pArray.Push_back(p3);
    69. 	pArray.Push_back(p4);
    70. 	pArray.Push_back(p5);
    71.  
    72. 	printPersonArray(pArray);
    73.  
    74. 	cout << "pArray的大小：" << pArray.getSize() << endl;
    75. 	cout << "pArray的容量：" << pArray.getCapacity() << endl;
    76.  
    77. }
    78.  
    79. int main() {
    80.  
    81. 	//test01();
    82.  
    83. 	test02();
    84.  
    85. 	system("pause");
    86.  
    87. 	return 0;
    88. }

    总结：

    能够利用所学知识点实现通用的数组

  • 相关阅读:
    FTP主动模式和被动模式（2）- 防火墙对FTP的影响 ASPF
    STM32存储左右互搏 I2C总线读写FRAM MB85RC16
    R语言使用epiDisplay包的aggregate函数将数值变量基于因子变量拆分为不同的子集，计算每个子集的汇总统计信息、计算单个连续变量的分组汇总统计信息
    Python 绘制反高斯光束光强分布
    FGH40N60SMD安森美车规IGBT，ASEMI原厂代理FGH40N60SMD
    三、创建各个展示模块组件
    egui常用组件
    Flink 实时数仓（一）【实时数仓&离线数仓对比】
    [附源码]计算机毕业设计JAVA龙虎时代健身房管理系统
    web前端面试-- js深拷贝的一些bug，特殊对象属性（RegExp，Date，Error，Symbol，Function）处理，循环引用weekmap处理
  • 原文地址：https://blog.csdn.net/weixin_45922730/article/details/128177230