• 浅谈C++|模板篇

    一.模板模板概念

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

     模板的特点：

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

    2.模板的通用并不是万能的

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

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

     二.函数模板

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

    2.1语法

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

    自动推导类型代码实例：

    1. #include 
    2. using namespace std;
    3. template<typename T>
    4. void my_swap(T& a, T& b) {
    5. 	T temp = a;
    6. 	a = b;
    7. 	b = temp;
    8. }
    9.  
    10. int main() {
    11. 	int a = 10,b = 20;
    12. 	char a2 = 'a', b2 = 'b';
    13. 	string a3 = "abc", b3 = "efg";
    14. 	my_swap(a, b);
    15. 	my_swap(a2, b2);
    16. 	my_swap(a3, b3);
    17. 	cout << "a=" << a << " b=" << b << endl;
    18. 	cout << "a2=" << a2 << " b2=" << b2 << endl;
    19. 	cout << "a3=" << a3 << " b3=" << b3 << endl;
    20. 	return 0;
    21. }

     显示指定类型代码：

    1. #include 
    2. using namespace std;
    3. template<typename T>
    4. void my_swap(T& a, T& b) {
    5. 	T temp = a;
    6. 	a = b;
    7. 	b = temp;
    8. }
    9.  
    10. int main() {
    11. 	int a = 10,b = 20;
    12. 	char a2 = 'a', b2 = 'b';
    13. 	string a3 = "abc", b3 = "efg";
    14. 	my_swap<int>(a, b);
    15. 	my_swap<char>(a2, b2);
    16. 	my_swap(a3, b3);
    17. 	cout << "a=" << a << " b=" << b << endl;
    18. 	cout << "a2=" << a2 << " b2=" << b2 << endl;
    19. 	cout << "a3=" << a3 << " b3=" << b3 << endl;
    20. 	return 0;
    21. }

     2.2注意事项

    注意事项:
    1.自动类型推导，必须推导出一致的数据类型T,才可以使用

    2.模板必须要确定出T的数据类型，才可以使用

     代码实例：

    1. #include 
    2. using namespace std;
    3. template<typename T>
    4. void my_swap(T a, T B) {
    5. 	T temp = a;
    6. 	a = b;
    7. 	b = a;
    8. }
    9.  
    10. template<typename T>
    11. void fun() {
    12. 	cout << "函数模板调用" << endl;
    13. }
    14.  
    15. int mian() {
    16. 	//fun();//报错，因为不能推理出T的类型
    17. 	int a = 10, b = 20;
    18. 	fun<int>();   
    19. 	//必须这样写，int换为其它类型也可
    20. 	
    21.  
    22. 	//my_swap(10, 'p');
    23. 	//报错，类型不一致
    24.  
    25. 	my_swap(20, 90);  
    26.   
    27.     my_swap<int>(20, 90);  
    28. 	my_swap(a, b);
    29.  
    30. 	return 0;
    31. }

    2.3普通函数和模板函数的区别

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

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

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

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

    1. #include 
    2. using namespace std;
    3. void fun(int one, int two) {
    4. 	cout << "one=" << one << " two=" << two << endl;
    5. }
    6. template<typename T>
    7. void fun1(T one, T two) {
    8. 	cout << "one=" << one << " two=" << two << endl;
    9. }
    10.  
    11.  
    12. void ce() {
    13. 	int a = 10, b = 20;
    14. 	char c = 'a';
    15. 	fun(a, b);
    16. 	fun(a, c);
    17. 	fun1(a, b);
    18. 	//fun1(a, c);  
    19. 	//报错，因为自动推理类型不会发生隐式转换
    20.  
    21. 	fun1<int>(a, c);
    22.  
    23. }
    24. int main() {
    25. 	ce();
    26. 	return 0;
    27. }

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

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

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

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

    代码实例： 

    1. #include 
    2. using namespace std;
    3. void fun(int a,int b) {
    4. 	cout << a << ' ' << b << ' ' << endl;
    5. 	cout << "普通函数调用" << endl;
    6. }
    7.  
    8. template<class T>
    9. void fun(T a, T b) {
    10. 	cout << a << ' ' << b << ' ' << endl;
    11. 	cout << "模板函数调用" << endl;
    12. }
    13.  
    14.  
    15. template<class T>
    16. void fun(T a, T b,T c) {
    17. 	cout << a << ' ' << b << ' ' <
    18. 	cout << "模板函数调用" << endl;
    19. }
    20. int main() {
    21. 	fun(10,20);   //默认调用普通函数
    22. 	fun<>(10,90);  //空列表强制调用模板函数
    23. 	fun<>(10,90,90);  //模板函数可以发生重载
    24. 	return 0;
    25. }

     2.5模板的局限性

     局限性：

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

     代码实例：

    1. #include 
    2. using namespace std;
    3.  
    4. class person {
    5. public:
    6. 	person(string name, int temp) {
    7. 		this->name = name;
    8. 		this->temp = temp;
    9. 	}
    10. 	int temp;
    11. 	string name;
    12. };
    13.  
    14.  
    15. template <class T>
    16. bool eq(T a, T b) {
    17. 	if (a == b) {
    18. 		return true;
    19. 	}
    20. 	else {
    21. 		return false;
    22. 	}
    23. }
    24.  
    25. int main() {
    26. 	person p1("tom", 20);
    27. 	person p2("tom", 20);
    28. 	//报错，因为自定义的类型，重载‘=’运算符
    29. 	if (eq(p1, p2)) {
    30. 		cout << "=" << endl;
    31. 	}
    32. 	else {
    33. 		cout << "!=" << endl;
    34. 	}
    35. 	return 0;
    36. }

    此时模板函数不报错，但运行时会报错。因为类的‘==’没有重载。

     代码实例：

    1. #include 
    2. using namespace std;
    3. class person {
    4. public:
    5. 	person(string name, int temp) {
    6. 		this->name = name;
    7. 		this->temp = temp;
    8. 	}
    9. 	int temp;
    10. 	string name;
    11. };
    12. template <class T>
    13. bool eq(T a, T b) {
    14. 	if (a == b) {
    15. 		return true;
    16. 	}
    17. 	else {
    18. 		return false;
    19. 	}
    20. }
    21.  
    22. //实例化模板函数
    23. template<> bool eq(person a, person b) {
    24. 	if (a.name == b.name && a.temp == b.temp) {
    25. 		return true;
    26. 	}
    27. 	else {
    28. 		return false;
    29. 	}
    30. }
    31.  
    32.  
    33. int main() {
    34. 	person p1("tom", 20);
    35. 	person p2("tom", 20);
    36. 	//报错，因为自定义的类型，重载‘=’运算符
    37. 	if (eq(p1, p2)) {
    38. 		cout << "=" << endl;
    39. 	}
    40. 	else {
    41. 		cout << "!=" << endl;
    42. 	}
    43. 	return 0;
    44. }

    此时可以运行，函数模板实例化，相当于模板的补充。

    三.类模板

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

    类模板不能使用自动推导类型，只能用显示指定的方法。

    3.1语法 

    1. template<typename T1, typename T2>
    2. class person {
    3. public:
    4. 	person(T1 name, T2 age) {
    5. 		this->name = name;
    6. 		this->age = age;
    7. 	}
    8. 	T1 name;
    9. 	T2 age;
    10. };

    代码实例：

    1. #include 
    2. using namespace std;
    3. template<typename T1, typename T2>
    4. class person {
    5. public:
    6. 	person(T1 name, T2 age) {
    7. 		this->name = name;
    8. 		this->age = age;
    9. 	}
    10. 	T1 name;
    11. 	T2 age;
    12. };
    13.  
    14.  
    15. int main() {
    16. 	personint> P("TOM", 90);
    17. 	cout << P.name << ' ' << P.age << endl;
    18. 	return 0;
    19. }

     3.2类模板和函数模板区别

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

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

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

    代码实例： 

    1. #include 
    2. using namespace std;
    3. //类模板可以添加默认参数，但是要优先右边全有默认参数yuanze
    4. template<class T1=string, typename T2=int>
    5. class person {
    6. public:
    7. 	person(T1 name, T2 age) {
    8. 		this->name = name;
    9. 		this->age = age;
    10. 	}
    11. 	T1 name;
    12. 	T2 age;
    13. };
    14. int main() {
    15. 	//person P("TOM", 90); //报错因为。类模板没有自动推导型
    16. 	personint> P("TOM", 90);
    17. 	//有默认参数，可以省略类型，但是<>不能省略
    18. 	person<> P1("SOM", 900);
    19. 	cout << P.name << ' ' << P.age << endl;
    20. 	cout << P1.name << ' ' << P.age << endl;
    21. 	return 0;
    22. }

    注意：< >不可以省略，设置默认参数时，优先右边。

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

    类模板中成员函数和普通类中成员函数创建时机是有区别的:
    1.普通类中的成员函数—开始就可以创建
    2.类模板中的成员函数在调用时才创建

    代码实例：

    1. #include 
    2. using namespace std;
    3. class person1 {
    4. public:
    5. 	void fun1() {
    6. 		cout << "person1的fun函数调用" << endl;
    7. 	}
    8. };
    9. class person2 {
    10. public:
    11. 	void fun2() {
    12. 		cout << "person2的fun函数调用" << endl;
    13. 	}
    14. };
    15.  
    16. template<typename T>
    17. class p {
    18. public:
    19. 	p(T p) {
    20. 		this->fun = p;
    21. 	}
    22. 	T fun;
    23. 	void fun1() {
    24. 		//定义时不报错，只有实例化后，调用此函数才会检测是否报错。
    25. 		fun.fun1();
    26. 	}
    27. 	void fun2() {
    28. 		//定义时不报错，只有实例化后，调用此函数才会检测是否报错。
    29. 		fun.fun2();
    30. 	}
    31. };
    32.  
    33.  
    34. int main() {
    35. 	person1 p1;
    36. 	p p(p1);
    37. 	//此时会正常运行，不会报错，因为没有调用p.fun2();
    38. 	p.fun1();
    39. 	//p.fun2();   运行报错
    40. 	return 0;
    41. }

    3.4类模板做函数参数

    —共有三种传入方式:
    1.指定传入的类型------------直接显示对象的数据类型

    ⒉参数模板化------------------将对象中的参数变为模板进行传递
    3.整个类模板化----------------将这个对象类型模板化进行传递

    3.4.1指定传入

    代码实例：

    1. #include 
    2. using namespace std;
    3. //默认参数
    4. template<class T1=string,class T2=int>
    5. class person {
    6. public:
    7. 	T1 name;
    8. 	T2 id;
    9. 	person(T1 name, T2 id) {
    10. 		this->name = name;
    11. 		this->id = id;
    12. 	}
    13. 	void fun() {
    14. 		cout << name << ' ' << id << endl;
    15. 	}
    16. };
    17.  
    18. //此函数不是模板函数，所以其参数要具体的参数
    19. void fun(personint>& p) {
    20. 	p.fun();
    21. }
    22.  
    23. int main() {
    24. 	personint> p("孙悟空", 78);
    25. 	fun(p);
    26. 	return 0;
    27. }

     3.4.2参数模板化

    代码实例：

    1. #include 
    2. using namespace std;
    3. //默认参数
    4. template<class T1 = string, class T2 = int>
    5. class person {
    6. public:
    7. 	T1 name;
    8. 	T2 id;
    9. 	person(T1 name, T2 id) {
    10. 		this->name = name;
    11. 		this->id = id;
    12. 	}
    13. 	void fun() {
    14. 		cout << name << ' ' << id << endl;
    15. 	}
    16. };
    17.  
    18. //实际上是创建模板函数
    19. template<class T1,class T2>
    20. void fun(person& p) {
    21. 	p.fun();
    22. }
    23.  
    24. int main() {
    25. 	personint> p("猪八戒", 19);
    26. 	fun(p);
    27. 	return 0;
    28. }

    3.4.3类模板化

    代码实例：

    1. #include 
    2. #include 
    3. using namespace std;
    4. //默认参数
    5. template<class T1 = string, class T2 = int>
    6. class person {
    7. public:
    8. 	T1 name;
    9. 	T2 id;
    10. 	person(T1 name, T2 id) {
    11. 		this->name = name;
    12. 		this->id = id;
    13. 	}
    14. 	void fun() {
    15. 		cout << name << ' ' << id << endl;
    16. 	}
    17. };
    18.  
    19. //将整个类作为一个类型，创建模板函数
    20. template<class T1>
    21. void fun(T1& p) {
    22. 	p.fun();
    23. }
    24.  
    25. int main() {
    26. 	personint> p("沙僧", 19);
    27. 	fun(p);
    28. 	return 0;
    29. }

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

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

     3.5类模板与继承

    当类模板碰到继承时,需要注意一下几点:
    1.当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型，如果不指定，编译器无法给子类分配内存。
    2.如果想灵活指定出父类中T的类型,子类也需变为类模板。

     1.代码实例：

    1. #include 
    2. using namespace std;
    3. template<typename T>
    4. class father {
    5. public:
    6. 	T name;
    7. };
    8.  
    9. //class father :public son 
    10. //如果想灵活指定出父类中T的类型,子类也需变为类模板。
    11. class son :public father {
    12. public:
    13. 	son(string name) {
    14. 		this->name = name;
    15. 	}
    16. 	void fun() {
    17. 		cout << this->name << endl;
    18. 	}
    19. };
    20.  
    21. int main() {
    22. 	son s("Tom");
    23. 	s.fun();
    24. 	return 0;
    25. }

     2.代码实例：

    1. #include 
    2. using namespace std;
    3. template<typename T>
    4. class father {
    5. public:
    6. 	T name;
    7. };
    8.  
    9. //class father :public son 
    10. //父类是模板类时，子类继承时要指定模板列表
    11. template<class T1,class T2>
    12. class son :public father {
    13. public:
    14. 	T1 id;
    15. 	son(T1 id,T2 name) {
    16. 		this->name = name;
    17. 		this->id = id;
    18. 	}
    19. 	void fun() {
    20. 		cout << this->name << endl;
    21. 		cout << this->id << endl;
    22. 	}
    23. };
    24.  
    25. int main() {
    26. 	son<int,string> s(100,"Tom");
    27. 	s.fun();
    28. 	return 0;
    29. }

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

    代码实例：

    1. #include 
    2. using namespace std;
    3. template<class T1,class T2>
    4. class person {
    5. public:
    6. 	T1 name;
    7. 	T2 id;
    8. 	person(T1 name, T2 id);
    9. 	void fun();
    10. 		
    11. };
    12.  
    13. template<class T1, class T2>
    14. person::person(T1 name, T2 id) {
    15. 	this->name = name;
    16. 	this->id = id;
    17. }
    18.  
    19. template<class T1, class T2>
    20. void person::fun() {
    21. 	cout << name << endl;
    22. 	cout << id << endl;
    23. }
    24.  
    25. int main() {
    26. 	personint> p("tom", 100);
    27. 	p.fun();
    28. 	return 0;
    29. }

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

    3.7类模板分文件编写

    问题:

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

    解决

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

     代码：

    person.hpp

    1. #include 
    2. using namespace std;
    3.  
    4. template<class T1 = string, class T2 = int>
    5. class person {
    6. public:
    7. 	T1 name;
    8. 	T2 age;
    9. 	person(T1 name, T2 age);
    10. 	void person_show();
    11. };
    12.  
    13. template<class T1, class T2>
    14. person::person(T1 name, T2 age) {
    15. 	this->name = name;
    16. 	this->age = age;
    17. }
    18.  
    19. template<class T1, class T2>
    20. void person::person_show() {
    21. 	cout << this->name << endl << this->age << endl;
    22. }

    person.cpp

    1. #include "person.hpp";
    2. int main() {
    3. 	person<> p("猪八戒", 100);
    4. 	p.person_show();
    5. 	return 0;
    6. }

    3.8类模板和友元

    全局函数类内实现-直接在类内声明友元即可 
    全局函数类外实现·需要提前让编译器知道全局函数的存在 

    类内实现 

     代码：

    1. #include 
    2. using namespace std;
    3. template<class T1=string,class T2=int>
    4. class person {
    5. //定义友元函数，属于全局函数
    6. 	friend void person_show(person p) {
    7. 		cout << p.name << endl << p.age << endl;
    8. 	}
    9. public:
    10. 	person(T1 name, T2 age);
    11. private:
    12. 	T1 name;
    13. 	T2 age;
    14. };
    15.  
    16. template<class T1, class T2>
    17. person::person(T1 name, T2 age) {
    18. 	this->name = name;
    19. 	this->age = age;
    20. }
    21.  
    22.  
    23. int main() {
    24. 	person<> p("小明", 100);
    25. 	person_show(p);
    26. 	return 0;
    27. }

     

     类外实现

    代码：

    1. #include 
    2. using namespace std;
    3.  
    4. //先声明有person类，防止报错
    5. template<class T1, class T2>
    6. class person;
    7.  
    8. //写在person定义之前，防止找不到报错
    9. template<class T1, class T2>
    10. void person_show(person &p) {
    11. 	cout << p.name << endl << p.age << endl;
    12. }
    13.  
    14. template<class T1,class T2>
    15. class person {
    16. 	//friend void person_show(person& p);  
    17. 	//错误写法,因为person_show是模板函数，此时T1是模板没的T1
    18. 	friend void person_show<>(person& p);
    19. 	//正确写法，加入模板列表声明是模板
    20. public:
    21. 	person(T1 name, T2 age);
    22. private:
    23. 	T1 name;
    24. 	T2 age;
    25. };
    26.  
    27. template<class T1, class T2>
    28. person::person(T1 name, T2 age) {
    29. 	this->name = name;
    30. 	this->age = age;
    31. }
    32.  
    33.  
    34. int main() {
    35. 	personint> p("猪八戒", 100);
    36. 	person_show(p);
    37. 	return 0;
    38. }

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

    类模板案例

    案例描述: 实现一个通用的数组类，要求如下
    。可以对内置数据类型以及自定义数据类型的数据进行存储
    。将数组中的数据存储到堆区
    。构造函数中可以传入数组的容量
    。提供对应的拷贝构造函数以及operator=防止浅拷贝问题。

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

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

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

    代码 

    myArray.hpp

    1. #pragma
    2. #include 
    3. using namespace std;
    4.  
    5. template<class T>
    6. class myArray {
    7. public:
    8. 	myArray(int capacity);
    9. 	myArray(myArray& p);
    10. 	~myArray();
    11.  
    12. 	//重载=，防止浅拷贝
    13. 	myArray& operator=(const myArray& p) {
    14. 		if (this->Array != NULL) {
    15. 			delete[] this->Array;
    16. 			this->Array = NULL;
    17. 		}
    18. 		this->capacity = p.capacity;
    19. 		this->size = p.size;
    20. 		this->Array = p.Array;
    21. 		for (int i = 0; i < this->size; ++i) {
    22. 			this->Array[i] = p.Array[i];
    23. 		}
    24. 	}
    25. 	T& operator[](int index) {
    26. 		return this->Array[index];
    27. 	}
    28. 	void push_back(const T& val);
    29. 	void pop_back();
    30. 	int getsize() {
    31. 		return this->size;
    32. 	}
    33. 	int getcapacity() {
    34. 		return this->capacity;
    35. 	}
    36. private:
    37. 	T* Array;
    38. 	int size;
    39. 	int capacity;
    40. };
    41.  
    42. //拷贝构造函数，注意要用深拷贝
    43. template<class T>
    44. myArray::myArray(myArray& p) {
    45. 	this->size = p.size;
    46. 	this->capacity = p.capacity;
    47. 	this->Array = new T[this->capacity];
    48. 	for (int i = 0; i < this->size; ++i) {
    49. 		this->Array[i] = p.Array[i];
    50. 	}
    51. }
    52.  
    53. //有参构造函数
    54. template<class T>
    55. myArray::myArray(int capacity) {
    56. 	this->capacity = capacity;
    57. 	this->Array = new T[this->capacity];
    58. 	this->size = 0;
    59. }
    60.  
    61. //析构函数
    62. template<class T>
    63. myArray::~myArray() {
    64. 	if (this->Array != NULL) {
    65. 		delete[] this->Array;
    66. 		this->Array = NULL;
    67. 	}	
    68. }
    69.  
    70. template<class T>
    71. void myArray :: push_back(const T& val) {
    72. 	if (this->size == this->capacity) {
    73. 		return;
    74. 	}
    75. 	this->Array[this->size++] = val;
    76. }
    77.  
    78. template<class T>
    79. void myArray ::pop_back() {
    80. 	if (this->size == 0) {
    81. 		return;
    82. 	}
    83. 	--this->size;
    84. }

    main.cpp

    1. #include "myArray.hpp"
    2. class person {
    3. public:
    4. 	string name;
    5. 	int age;
    6. 	person() {}
    7. 	person(string name, int age) {
    8. 		this->name = name;
    9. 		this->age = age;
    10. 	}
    11. };
    12.  
    13.  
    14. void myprintf(myArray& p) {
    15. 	for (int i = 0; i < p.getsize(); ++i) {
    16. 		cout << p[i].name << "  " << p[i].age << endl;
    17. 	}
    18. }
    19.  
    20.  
    21. void fun() {
    22. 	person p1("小明", 100);
    23. 	person p2("小壮", 130);
    24. 	person p3("小聪", 103);
    25. 	person p4("小红", 1560);
    26. 	person p5("小懒", 190);
    27. 	//调用默认构造函数
    28. 	myArray p(10);
    29. 	p.push_back(p1);
    30. 	p.push_back(p2);
    31. 	p.push_back(p3);
    32. 	p.push_back(p4);
    33. 	p.push_back(p5);
    34.  
    35. 	cout << p.getsize() << endl;
    36. 	cout << p.getcapacity() << endl;
    37. 	myprintf(p);
    38. 	p.pop_back();
    39. 	cout << "弹出最后一个" << endl;
    40. 	myprintf(p);
    41. 	cout << "判断拷贝构造函数" << endl;
    42. 	myArray p6(p);
    43. 	myprintf(p6);
    44. 	cout << "判断operator=" << endl;
    45. 	myArray p7(0);
    46. 	p7 = p;
    47. 	myprintf(p7);
    48. }
    49. int main() {
    50. 	fun();
    51. 	return 0;
    52. }

  • 相关阅读:
    目标检测——ADAS实战
    CSS之margin塌陷
    【目标检测】【AnchorFree】【P-PicoDet】 移动端的目标检测器
    服务器cpu一直处于100%解决思路
    语义熵：QoE-Aware Resource Allocation for Semantic Communication Networks
    Java高级——内存分配机制
    Linux日志超详细使用操作
    数据结构——排序
    OSPFv2 和 OSPFv3 的区别？
    伯俊ERP与金蝶云星空对接集成表头表体组合查询打通应收单新增
  • 原文地址：https://blog.csdn.net/m0_73731708/article/details/132892775