• C++之模板

    本阶段主要针对C++泛型编程和ST技术做详细讲解，探讨C++更深层的使用

    1.1 模板的概念

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

    模板的特点:

    模板不可以直接使用，它只是一个框架

    模板的通用并不是万能的 

    1.2 函数模板

    C++另一种编程思想称为 泛型编程，主要利用的技术就是模板

    C++提供两种模板机制:函数模板和类模板

    1.2.1 函数模板语法

    函数模板作用:

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

    语法:

    1. template<typename T>
    2.  
    3. 函数声明或定义

    解释:

    template--- 声明创建模板

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

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

    示例：

    1. #include<iostream>
    2. using namespace std;
    3.  
    4. template<typename T>>//声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用的数据类型
    5. void myswap(T &a,T &b)
    6. {
    7. 	T temp = a;
    8. 	a = b;
    9. 	b = temp;
    10. }
    11.  
    12.  
    13. void test01()
    14. {
    15. 	int a = 10;
    16. 	int b = 20;
    17.  
    18. 	//1,自动类型推导
    19. 	cout << "第一次交换：自动类型推导" << endl;
    20. 	myswap(a, b);
    21. 	cout << "a=" << a << endl;
    22. 	cout << "b=" << b << endl;
    23.  
    24. 	//2,显示指定类型
    25. 	cout << "第二次交换：显示指定类型" << endl;
    26. 	myswap<int>(a, b);
    27. 	cout << "a=" << a << endl;
    28. 	cout << "b=" << b << endl;
    29.  
    30. }
    31.  
    32. int main()
    33. {
    34. 	test01();
    35.  
    36. 	system("pause");
    37. 	return 0;
    38. }

     

    总结:

    函数模板利用关键字 template

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

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

    1.2.2 函数模板注意事项

    注意事项:
    自动类型推导，必须推导出    一致的数据类型T,才可以使用
    模板必须要确定出T的数据类型，才可以使用

    示例：

    1. #include<iostream>
    2. using namespace std;
    3.  
    4. template<typename T>//typename可以替换成class
    5. void myswap(T& a, T& b)
    6. {
    7. 	T temp = a;
    8. 	a = b;
    9. 	b = temp;
    10. }
    11.  
    12. void test01()
    13. {
    14. 	int a = 10;
    15. 	int b = 20;
    16.  
    17. 	//1,自动类型推导，必须推导出一致的数据类型T, 才可以使用
    18. 	cout << "第一次交换：自动类型推导" << endl;
    19. 	myswap(a, b);//正确
    20. 	cout << "a=" << a << endl;
    21. 	cout << "b=" << b << endl;
    22.  
    23. 	cout << "第二次交换：显示指定类型" << endl;
    24. 	myswap<int>(a, b);
    25. 	cout << "a=" << a << endl;
    26. 	cout << "b=" << b << endl;
    27.  
    28. }
    29. //2，模板必须要确定出T的数据类型，才可以使用
    30. template<class T>
    31. void func()
    32. {
    33. 	cout << "func调用" << endl;
    34. }
    35.  
    36. void test02()
    37. {
    38. 	//func();错误，模板不能独立使用，必须确定出T的模型才可以
    39. 	func<int>();//利用显示指定类型的方式，给T一个类型，才可以使用该模板
    40. }
    41.  
    42. int main()
    43. {
    44. 	test01();
    45.  
    46. 	test02();
    47. 	system("pause");
    48. 	return 0;
    49. }

    1.2.3 函数模板案例

    案例描述:

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

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

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

    1. #include<iostream>
    2. using namespace std;
    3.  
    4. //利用函数模板封装一个排序的函数，可以对不同数据类型数组进行排序
    5. //规则 从小到大
    6. //算法  选择
    7. //测试 char,数组，int 数组
    8.  
    9. //打印函数模板
    10. template<typename T>
    11. void printArray(T arr[], int len)
    12. {
    13. 	for (int i = 0; i < len; i++)
    14. 	{
    15. 		cout << arr[i] << " ";
    16.     }
    17. 	cout << endl;
    18. }
    19.  
    20. //交换函数模板
    21. template<class T>
    22. void mySwap(T &a, T &b)
    23. {
    24. 	T temp = a;
    25. 	a = b;
    26. 	b = temp;
    27. }
    28.  
    29. //排序算法
    30. template<class T>
    31. void mySort(T arr[], int len)
    32. {
    33. 	for (int i = 0; i < len; i++)
    34. 	{
    35. 		int max = i;//认定最大值的下标
    36. 		for (int j = i + 1; j < len; j++)
    37. 		{
    38. 			//认定的最大值 比 遍历的数值要小，说明j下边的元素是才是真正的最大值
    39. 			if (arr[max] < arr[j])
    40. 			{
    41. 				max = j;
    42. 			}
    43. 		}
    44. 		if (max != i)
    45. 		{
    46. 			//交换max和i元素的下标
    47. 			mySwap(arr[max], arr[i]);
    48. 		}
    49. 	}
    50. }
    51.  
    52. void test02()
    53. {
    54. 	int intArr[] = { 7,5,1,3,9,2,4,6,8 };
    55. 	int num = sizeof(intArr) / sizeof(intArr[0]);
    56. 	mySort(intArr, num);
    57. 	printArray(intArr, num);
    58. }
    59.  
    60. void test01()
    61. {
    62. 	//测试char数组
    63. 	char charArr[7] = "badcef";
    64. 	int num = sizeof(charArr) / sizeof(char);
    65. 	mySort(charArr, num);
    66. 	printArray(charArr, num);
    67. }
    68.  
    69. int main()
    70. {
    71. 	test01();
    72.  
    73. 	test02();
    74.  
    75. 	system("pause");
    76. 	return 0;
    77. }

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

    普通函数与函数模板区别

    普通函数调用时可以发生自动类型转换(隐式类型转换)

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

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

    示例：

    1. #include<iostream>
    2. using namespace std;
    3.  
    4. //普通函数与函数模板的区别
    5.  
    6. //普通函数调用时可以发生自动类型转换(隐式类型转换)
    7. //函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
    8. //如果利用显示指定类型的方式，可以发生隐式类型转换 
    9.  
    10. //普通数组
    11. int myAdd01(int a,int b)
    12. {
    13. 	return a + b;
    14. }
    15.  
    16. //函数模板
    17. template<class T>
    18. T myAdd02(T a, T b)
    19. {
    20. 	return a + b;
    21. }
    22.  
    23. void test01()
    24. {
    25. 	int a = 10;
    26. 	int b = 20;
    27. 	char c = 'c';
    28. 	cout << "a + b =" << myAdd01(a, b) << endl;
    29. 	cout <<"a + c =" << myAdd01(a, c) << endl;//a - 97 c - 99
    30.  
    31. 	//自动类型推导
    32. 	cout << "自动类型推导" << endl;
    33. 	cout << myAdd02(a, b) << endl;
    34. 	//cout << myAdd02(a, c) << endl;//报错，不会发生隐式类型转换
    35.  
    36. 	//显示指定类型
    37. 	cout << "显示指定类型" << endl;
    38. 	cout << myAdd02<int>(a, c) << endl;
    39. 	//会发生隐式类型转换
    40. }
    41.  
    42. int main()
    43. {
    44. 	
    45. 	test01();
    46. 	system("pause");
    47.  
    48. 	return 0;
    49. }

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

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

    调用规则如下:

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

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

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

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

    示例1：

    1. #include<iostream>
    2. using namespace std;
    3.  
    4. //1.如果函数模板和普通函数都可以实现，优先调用普通函数
    5. void myprint(int a, int b)
    6. {
    7. 	cout << "调用的普通函数" << endl;
    8. }
    9.  
    10. template<class T>
    11. void myprint(T a, T b)
    12. {
    13. 	cout << "调用的模板函数" << endl;
    14. }
    15.  
    16. void test01()
    17. {
    18. 	int a = 10;
    19. 	int b = 10;
    20. 	myprint(a, b);
    21. }
    22.  
    23. int main()
    24. {
    25.  
    26. 	test01();
    27. 	system("pause");
    28.  
    29. 	return 0;
    30. }

    示例2： 

    1. #include<iostream>
    2. using namespace std;
    3. //2.可以通过空模板参数列表来强制调用函数模板
    4.  
    5. void myprint(int a, int b)
    6. {
    7. 	cout << "调用的普通函数" << endl;
    8. }
    9.  
    10. template<class T>
    11. void myprint(T a, T b)
    12. {
    13. 	cout << "调用的模板函数" << endl;
    14. }
    15.  
    16. void test01()
    17. {
    18. 	int a = 10;
    19. 	int b = 10;
    20. 	myprint<>(a, b);
    21. }
    22.  
    23. int main()
    24. {
    25.  
    26. 	test01();
    27. 	system("pause");
    28.  
    29. 	return 0;
    30. }

    示例3：

    1. #include<iostream>
    2. using namespace std;
    3. void myprint(int a, int b)
    4. {
    5. 	cout << "调用的普通函数" << endl;
    6. }
    7.  
    8. template<class T>
    9. void myprint(T a, T b)
    10. {
    11. 	cout << "调用的模板函数" << endl;
    12. }
    13.  
    14. template<class T>
    15. void myprint(T a, T b,T c)
    16. {
    17. 	cout << "调用的模板重载函数" << endl;
    18. }
    19.  
    20. void test01()
    21. {
    22. 	int a = 10;
    23. 	int b = 10;
    24.  
    25. 	//3,函数也可以发生重载
    26. 	int c = 10;
    27. 	myprint(a, b, c);
    28.  
    29. 	//4，如果函数模板可以产生更好的匹配,优先调用函数模板
    30. 	char c1 = 'a';
    31. 	char c2 = 'c';
    32. 	myprint(c1,c2);
    33. 	
    34. }
    35.  
    36. int main()
    37. {
    38.  
    39. 	test01();
    40. 	system("pause");
    41.  
    42. 	return 0;
    43. }

     

    总结：既然提供了函数模板，最好就不要提供普通函数，否则容易出现二义性 

    1.2.6 模板的局限性

    局限性:

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

    例如:

    1. template<class T>
    2. void f(T a, T b)
    3. {
    4. a = b;
    5. }

    在上述代码中提供的赋值操作，如果传入的a和b是一个数组，就无法实现了

    再例如:

    1. template<class T>
    2. void f(T a, T b)
    3. {
    4.    if(a>b)
    5.    {
    6.      ...
    7.    }
    8. }

    在上述代码中，如果T的数据类型传入的是像Person这样的自定义数据类型，也无法正常运行
    因此C++为了解决这种问题，提供模板的重载，可以为这些特定的类型提供具体化的模板

    1. #include<iostream>
    2. using namespace std;
    3. #include<string>
    4.  
    5. //模板的局限性
    6. //模板并不是万能的，有些特定数据类型，需要用具体化方式做特殊实现
    7.  
    8. class Person
    9. {
    10. public:
    11. 	Person(string name, int age)
    12. 	{
    13. 		this->m_Name = name;
    14. 		this->m_age = age;
    15. 	}
    16. 	string m_Name;
    17. 	int m_age;
    18. };
    19.  
    20.  
    21. template<class T> 
    22. bool myCompare(T &a,T &b)
    23. {
    24. 	if (a == b)
    25. 	{
    26. 		return true;
    27. 	}
    28. 	else
    29. 	{
    30. 		return false;
    31. 	}
    32. }
    33.  
    34. //利用具体化Person版本实现代码，具体化优先调用
    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. 	bool ret = myCompare(a, b);
    52. 	if (ret)
    53. 	{
    54. 		cout << "a==b" << endl;
    55. 	}
    56. 	else
    57. 	{
    58. 		cout << "a!=b" << endl;
    59. 	}
    60. }
    61. void test02()
    62. {
    63. 	Person p1("Tom", 10);
    64. 	Person p2("Tom", 10);
    65.  
    66. 	bool ret = myCompare(p1, p2);
    67. 	if (ret)
    68. 	{
    69. 		cout << "p1==p2" << endl;
    70. 	}
    71. 	else
    72. 	{
    73. 		cout << "p1!=p2" << endl;
    74. 	}
    75. }
    76.  
    77.  
    78. int main()
    79. {
    80. 	test01();
    81. 	
    82. 	test02();
    83.  
    84. 	system("pause");
    85.  
    86. 	return 0;
    87. }

    总结：

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

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

    1.3 类模板

    1.3.1 类模板语法

    类模板作用:

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

    1. //语法:
    2.  
    3. template<typename T>
    4.  类

    解释:

    template…声明创建模板

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

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

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

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

    1.3.2 类模板与函数模板区别

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

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

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

    示例：

    1. #include<iostream>
    2. using namespace std;
    3. #include<string>
    4.  
    5. //类模板与函数模板的区别
    6. template<class NameYtpe, class AgeType = int>
    7. class Person
    8. {
    9. public:
    10. 	Person(NameYtpe name, AgeType  age )
    11. 	{
    12. 		this->m_Name = name;
    13. 		this->m_Age = age;
    14. 	}
    15.  
    16. 	void ShowPerson()
    17. 	{
    18. 		cout << "name: " << this->m_Name << "\t" << "age: " << this->m_Age << endl;
    19. 	}
    20.  
    21. 	NameYtpe m_Name;
    22. 	AgeType m_Age;
    23. };
    24.  
    25. //1.类模板没有自动类型推导的使用方式
    26. void test01()
    27. {
    28. 	//Person p("孙悟空",1000);
    29. 	Person<string, int>p1("孙悟空", 99);//只能用显示指定类型
    30. 	p1.ShowPerson();
    31. }
    32. //2.类模板在模板参数列表中可以有默认参数
    33. void test02()
    34. {
    35. 	Person<string>p2("猪八戒", 999);
    36. 	p2.ShowPerson();
    37. }
    38.  
    39.  
    40. int main()
    41. {
    42. 	test01();
    43. 	test02();
    44. 	system("pause");
    45. 	return 0;
    46. }

     

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

    类模板中成员函数和普通类中成员函数创建时机是有区别的:

    普通类中的成员函数一开始就可以创建

    类模板中的成员函数在调用时才创建

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

    1.3.4 类模板对象做函数参数

    学习目标:

    类模板实例化出的对象，向函数传参的方式

    共有三种传入方式:

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

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

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

    示例：

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

    总结：

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

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

    1.3.5 类模板与继承

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

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

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

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

    1. #include<iostream>
    2. using namespace std;
    3. #include<string>
    4.  
    5. //类模板与继承
    6. template<class T>
    7. class Base
    8. {
    9. 	T m;
    10. };
    11.  
    12. //class Son:public Base//错误，必须要指定父类中的T类型，才能继承给子类
    13. class Son1 :public Base<int>
    14. {
    15. 	
    16. };
    17.  
    18. void test01()
    19. {
    20. 	Son1 s1;
    21. }
    22.  
    23. //如果想灵活指定出父类中T的类型，子类也需变为类模板
    24. template<class T1,class T2>
    25. class Son2 :public Base<T2>
    26. {
    27. public:
    28. 	Son2()
    29. 	{
    30. 		cout << "T1的类型为：" << typeid(T1).name() << endl;
    31. 		cout << "T2的类型为：" << typeid(T2).name() << endl;
    32. 	}
    33. 	T1 obj;
    34. };
    35.  
    36. void test02()
    37. {
    38. 	Son2<int, char>S2;
    39. }
    40.  
    41.  
    42. int main()
    43. {
    44.  
    45. 	//test01();
    46.  
    47. 	test02();
    48.  
    49. 	//test03();
    50.  
    51. 	system("pause");
    52. 	return 0;
    53. }

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

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

    示例：

    1. #include<iostream>
    2. using namespace std;
    3. #include<string>
    4.  
    5. template<class T1, class T2>
    6. class Person
    7. {
    8. public:
    9. 	Person(T1 name, T2 age);
    10. 	
    11. 	void ShowPerson();
    12.  
    13. 	T1 m_Name;
    14. 	T2 m_Age;
    15. };
    16.  
    17. //构造函数的类外实现
    18. template<class T1, class T2>
    19. Person<T1,T2>::Person(T1 name, T2 age)
    20. {
    21. 	this->m_Name = name;
    22. 	this->m_Age = age;
    23. }
    24.  
    25. //成员函数类外实现
    26. template<class T1, class T2>
    27. void Person<T1, T2>::ShowPerson()
    28. {
    29. 	cout << "name: " << this->m_Name << "\t" << "age: " << this->m_Age << endl;
    30. }
    31.  
    32. void test01()
    33. {
    34. 	Person<string, int>P("Tom", 20);
    35. 	P.ShowPerson();
    36. }
    37.  
    38. int main()
    39. {
    40.  
    41. 	test01();
    42.  
    43. 	system("pause");
    44. 	return 0;
    45. }

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

    1.3.7 类模板分文件编写

    学习目标:

    掌握类模板成员函数分文件编写产生的问题以及解决方式

    问题:

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

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

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

    我们首先将类模板成员函数类外实现的文件分为以下三个文件：

    Person.h

    1. #include"Person.h"
    2. //构造函数的类外实现
    3. template<class T1, class T2>
    4. Person<T1, T2>::Person(T1 name, T2 age)
    5. {
    6. 	this->m_Name = name;
    7. 	this->m_Age = age;
    8. }
    9.  
    10. //成员函数类外实现
    11. template<class T1, class T2>
    12. void Person<T1, T2>::ShowPerson()
    13. {
    14. 	cout << "name: " << this->m_Name << "\t" << "age: " << this->m_Age << endl;
    15. }

    Person.cpp

    1. #pragma once
    2. #include<iostream>
    3. using namespace std;
    4. #include<string>
    5.  
    6. //类模板分文件编写问题以及解决
    7. template<class T1, class T2>
    8. class Person
    9. {
    10. public:
    11. 	Person(T1 name, T2 age);
    12.  
    13. 	void ShowPerson();
    14.  
    15. 	T1 m_Name;
    16. 	T2 m_Age;
    17. };
    18.

     类模板分文件编写.cpp

    1. #include"person.h"
    2. void test01()
    3. {
    4. 	Person<string, int>P("Tom", 20);
    5. 	P.ShowPerson();
    6. }
    7.  
    8. int main()
    9. {
    10. 	test01();
    11. 	system("pause");
    12. 	return 0;
    13. }

     解决方法1：将类模板的头文件改为：#include"person.cpp"即可运行

    解决方法2：将.h和.cpp中的内容写到一起，将后缀名改为.hpp文件

     

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

    1.3.8 类模板与友元

    学习目标:

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

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

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

    示例：

    1. #include<iostream>
    2. using namespace std;
    3. #include<string>
    4.  
    5. template<class T1, class T2>
    6. class Person;
    7.  
    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. //通过全局函数，打印Perosn信息
    16. template<class T1,class T2>
    17. class Person
    18. {
    19. 	//全局函数类外实现
    20. 	//加空模板参数列表
    21. 	//如果全局函数 是类外实现，需要让编译器提前指定这个函数的存在
    22. 	friend void PrintPerson2<>(Person<T1, T2>p);
    23. public:
    24. 	//全局函数 类内实现
    25. 	friend void PrintPerson(Person<T1, T2>&p)
    26. 	{
    27. 		cout << "name: " << p.m_Name << "\t" << "age: " << p.m_Age << endl;
    28. 	}
    29.  
    30. 	Person(T1 name, T2 age)
    31. 	{
    32. 		this->m_Name = name;
    33. 		this->m_Age = age;
    34. 	}
    35. private:
    36. 	T1 m_Name;
    37. 	T2 m_Age;
    38. };
    39.  
    40. void test01()
    41. {
    42. 	Person<string, int>p("Tom", 100);
    43. 	PrintPerson(p);
    44. }
    45. //全局函数类外实现
    46. void test02()
    47. {
    48. 	Person<string, int>p("Jerry", 20);
    49. 	PrintPerson2(p);
    50. }
    51.  
    52. int main()
    53. {
    54. 	test01();
    55. 	test02();
    56. 	system("pause");
    57. 	return 0;
    58. }

    总结：建议全局函数做类内实现，用法简单，而且编译器可以直接识别 

    1.3.9 类模板案例

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

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

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

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

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

    提供尾插法和尾刚法对数组中的教据进行增加和刷除

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

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

    思路：

     

  • 相关阅读:
    YOLOV5改进：在C3模块不同位置添加D-LKA Attention（同时拥有SA注意力和大卷积核的能力）
    工具推荐 StartTool
    2022年痛风药行业定义及分类
    STM8应用笔记3.GPIO输出和输入
    BigDecimal不会丢失精度的浮点数
    SkyWalking快速上手（六）——告警
    AE& VAE 代码和结果记录
    行情分析——加密货币市场大盘走势（11.7）
    c++的作用域 （局部域，类域，名字命名空间，文件域）
    关于电话号码欺骗的一切
  • 原文地址：https://blog.csdn.net/bai_lan_ya/article/details/136749224