C++笔记5.09

知识点6 函数模板

C++的特点：封装、继承、多态

也是C++的特点：面向对象编程、泛型编程

案例：

1. #include <iostream>  
2.   
3. using namespace std;  
4.   
5. void swapInt(int &a, int &b)  
6. {  
7.     int tmp = a;  
8.     a = b;  
9.     b = tmp;  
10.     return;  
11. }  
12.   
13. void swapChar(char &a, char&b)  
14. {  
15.     char tmp = a;  
16.     a = b;  
17.     b = tmp;  
18.     return;  
19. }  
20.   
21. //函数模板templa是关键字  
22. //T由系统自动推导或者用户指定  
23. template<typename T>  
24. void mySwap(T &a, T&b)  
25. {  
26.     T tmp;  
27.     tmp = a;  
28.     a = b;  
29.     b = tmp;  
30. }  
31.   
32. int main()  
33. {  
34.     int data1 = 10, data2 = 20;  
35.     cout << "data1 = " << data1 << ", data2 = " << data2 << endl;  
36.     swapInt(data1,data2);  
37.     cout << "data1 = " << data1 << ", data2 = " << data2 << endl;  
38.   
39.     char data3 = 'a', data4 = 'b';  
40.     cout << "data3 = " << data3 << ", data4 = " << data4 << endl;  
41.     swapChar(data3,data4);  
42.     cout << "data3 = " << data3 << ", data4 = " << data4 << endl;  
43.   
44.     mySwap(data1,data2);//自动推导出T为int  
45.     mySwap(data3,data4);//自动推导出T为char  
46.     cout << "data1 = " << data1 << ", data2 = " << data2 << endl;  
47.     cout << "data3 = " << data3 << ", data4 = " << data4 << endl;  
48.     return 0;  
49. }  

用户指定T的类型

1. mySwap<int>(data1,data2);//用户指定T为int  

通过使用模板是为了实现泛型，可以减轻编程的工作量，增加函数的重用性。

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

函数模板不允许自动类型转换

C++编译器优先考虑普通函数，但是也可以通过空模板实参列表的语法限定编译器只能通过模板匹配。

函数模板也可以重载

案例2：函数模板调用的时机

1. #include <iostream>  
2.   
3. using namespace std;  
4.   
5. void myswap(int &a, int &b)  
6. {  
7.     cout << "普通函数" << endl;  
8.     int tmp = a;  
9.     a = b;  
10.     b = tmp;  
11.     return;  
12. }  
13.   
14. template<typename T>  
15. void mySwap(T &a, T&b)  
16. {  
17.     cout << "函数模板" << endl;  
18.     T tmp;  
19.     tmp = a;  
20.     a = b;  
21.     b = tmp;  
22. }  
23.   
24. int main()  
25. {  
26.     int data1 = 10, data2 = 20;  
27.     char data3 = 'a';  
28.     cout << "data1 = " << data1 << ", data2 = " << data2 << endl;  
29.     //模板函数和普通函数都识别的情况下优先选择普通函数  
30.     myswap(data1,data2);  
31.     cout << "data1 = " << data1 << ", data2 = " << data2 << endl;  
32.     myswap<int>(data1,data3);  
33.     return 0;  
34. }  

知识点7 使用函数模板进行排序

1. #include <iostream>  
2. #include <cstring>  
3. using namespace std;  
4.   
5. template<typename T>  
6. void myPrintArrayTemplate(T* arr, int len)  
7. {  
8.     int i = 0;  
9.     for(i=0;i<len;i++)  
10.         cout << arr[i] << " " ;  
11.     cout <<endl;  
12. }  
13.   
14. template<typename T>  
15. void mySortArrayTemplate(T* arr, int len)  
16. {  
17.     int i = 0, j = 0;  
18.     for(i=0;i<len-1;i++)  
19.     {  
20.         int min = i;  
21.         for(j=min+1;j<len;j++)  
22.         {  
23.             if(arr[min] > arr[j])  
24.                 min = j;  
25.         }  
26.   
27.         if(min != i)  
28.         {  
29.             T tmp = arr[min];  
30.             arr[min] = arr[i];  
31.             arr[i] = tmp;  
32.         }  
33.     }  
34. }  
35.   
36. int main()  
37. {  
38.     char str[] = "hello template";  
39.     int arr[] = {5,7,3,5,6,4,9,1,10};  
40.     int arr_len = sizeof(arr)/sizeof(arr[0]);  
41.   
42.     //用函数模板遍历数组  
43.     myPrintArrayTemplate(str,strlen(str));  
44.     myPrintArrayTemplate(arr,arr_len);  
45.     //用模板函数对数组排序  
46.     mySortArrayTemplate(str,strlen(str));  
47.     mySortArrayTemplate(arr,arr_len);  
48.     //用模板函数遍历数组  
49.     myPrintArrayTemplate(str,strlen(str));  
50.     myPrintArrayTemplate(arr,arr_len);  
51.     return 0;  
52. }  

知识点8 函数模板具体化

1. #include <iostream>  
2.   
3. using namespace std;  
4.   
5. class Person  
6. {  
7. public:  
8.     int a;  
9.     int b;  
10.     Person(int a, int b)  
11.     {  
12.         this->a = a;  
13.         this->b = b;  
14.         cout << "构造函数" << endl;  
15.     }  
16.   
17.     ~Person()  
18.     {  
19.         cout << "析构函数" << endl;  
20.     }  
21. };  
22.   
23. ostream& operator<<(ostream &out, Person &ob)  
24. {  
25.     out << "a = " << ob.a << ", b = " << ob.b;  
26. }  
27.   
28. template<typename T>  
29. T& myMax(T &a, T &b)  
30. {  
31.     return a>b ? a:b;  
32. }  
33.   
34. //方法一：提供函数模板具体化  
35. template<> Person& myMax(Person &ob1, Person &ob2)  
36. {  
37.     return ob1.a>ob2.b ? ob1:ob2;  
38. }  
39.   
40.   
41. int main()  
42. {  
43.     Person ob1(10,20);  
44.     Person ob2(100,200);  
45.     cout << ob1 << endl;  
46.     cout << ob2 << endl;  
47.     cout << myMax(ob1,ob2) << endl;  
48.     return 0;  
49. }  

知识点9 类模板

1. #include <iostream>  
2.   
3. using namespace std;  
4.   
5. //类模板  
6. template<class T1, class T2>  
7. class Data  
8. {  
9. private:  
10.     T1 name;  
11.     T2 num;  
12. public:  
13.     Data(T1 name, T2 num)  
14.     {  
15.         this->name = name;  
16.         this->num = num;  
17.         cout << "有参构造" << endl;  
18.     }  
19.   
20.     ~Data()  
21.     {  
22.         cout << "析构函数" << endl;  
23.     }  
24.   
25.     void showData()  
26.     {  
27.         cout << "name = " << this->name << " num = " << this->num <<endl;  
28.     }  
29. };  
30.   
31. int main()  
32. {  
33.     //类模板不能进行类型推导  
34.     Data <string,int>ob1("阿尔贝尔",114514);  
35.     ob1.showData();  
36.     Data <int, string>ob2(17,"伊利斯");  
37.     ob2.showData();  
38.     return 0;  
39. }  

知识点10 类模板作为函数的参数

1. #include <iostream>  
2.   
3. using namespace std;  
4.   
5. //类模板  
6. template<class T1, class T2>  
7. class Data  
8. {  
9.     friend void addData(Data<string,int> &ob);  
10. private:  
11.     T1 name;  
12.     T2 num;  
13. public:  
14.     Data(T1 name, T2 num)  
15.     {  
16.         this->name = name;  
17.         this->num = num;  
18.         cout << "有参构造" << endl;  
19.     }  
20.   
21.     ~Data()  
22.     {  
23.         cout << "析构函数" << endl;  
24.     }  
25.   
26.     void showData()  
27.     {  
28.         cout << "name = " << this->name << " num = " << this->num <<endl;  
29.     }  
30. };  
31.   
32. //类模板做函数参数  
33. void addData(Data<string,int> &ob)  
34. {  
35.     ob.name += "_shawodverse";  
36.     ob.num += 100;  
37.     return;  
38. }  
39.   
40. int main()  
41. {  
42.     Data<string, int> ob("阿尔贝尔", 114514);  
43.     addData(ob);  
44.     ob.showData();  
45.     return 0;  
46. }  

知识点11 类模板派生出普通类

1. #include <iostream>  
2. #include <cstring>  
3. using namespace std;  
4.   
5. //类模板  
6. template<class T>  
7. class Base  
8. {  
9. private:  
10.     T num;  
11. public:  
12.     Base(T num)  
13.     {  
14.         this->num = num;  
15.         cout << "有参构造" << endl;  
16.     }  
17.   
18.     ~Base()  
19.     {  
20.         cout << "析构函数" << endl;  
21.     }  
22.   
23.     void showNum(void)  
24.     {  
25.         cout << "num = " << this->num <<endl;  
26.     }  
27. };  
28.   
29. //类模板派生出普通类 必须给基类指定类型  
30. class Son1:public Base<int>  
31. {  
32. public:  
33.     Son1(int a):Base<int>(a)  
34.     {  
35.         cout << "Son1构造" << endl;  
36.     }  
37. };  
38.   
39. class Son2:public Base<string>  
40. {  
41. public:  
42.     Son2(string a):Base<string>(a)  
43.     {  
44.         cout << "Son2构造" << endl;  
45.     }  
46. };  
47. int main()  
48. {  
49.     Son1 ob1(100);  
50.     ob1.showNum();  
51.     Son2 ob2("ssdt");  
52.     ob2.showNum();  
53.   
54.     return 0;  
55. }