【c++】 模板初阶

泛型编程

写一个交换函数，在学习模板之前，为了匹配差异的参数范例，我们可以使用函数重载来实现。

2. void Swap(int& a, int& b)
3. {
4.         int c = a;
5.         a = b;
6.         b = c;
7. }
8. void Swap(char& a, char& b)
9. {
10.         char c = a;
11.         a = b;
12.         b = c;
13. }
14. void Swap(double& a, double& b)
15. {
16.         double c = a;
17.         a = b;
18.         b = c;
19. }
21. //...

复制代码

固然如许好像办理了标题，但是如许的操持写着太过贫苦，只要出现新范例就须要写新的函数，代码的复用率很低。有没有什么可以让我们一劳永逸呢？模板就可以实现这一功能。
这种通过抽象和模板化来编写可重用和机动的代码以此提升代码的可读性和维护性，同时克制代码重复的方式称为泛型编程。
函数模板

函数模板是c++中的一类机制，通过在函数界说中使用模板参数，我们可以编写一个函数，而在调用时根据实际参数的范例自动天生相应的版本。

2. template <class T>
3. void Swap(T& a, T& b)
4. {
5.         T c = a;
6.         a = b;
7.         b = c;
8. }

复制代码

如许编译器就可以根据传入的参数范例来天生对应的Swap()函数，大大进步了代码的复用率。下面我们来实验运行一下。

2. template <class T>
3. void Swap(T& a, T& b)
4. {
5.         T c = a;
6.         a = b;
7.         b = c;
8. }
9. int main(){        int a,b;        a = 1; b = 2;        double c, d;        c = 0.0; d = 1.2;        Swap(a, b);        Swap(c, d);        cout << a << "  " << b << endl;    cout << c << "  " << d << endl;        return 0;}

复制代码

我们发现，调用Swap()之后，int范例的ab和double范例的cd都完成了交换。但是他们是否调的是同一个函数呢？
转到反汇编： 

我们发现两次调用的是差异的Swap()函数，根据传入参数范例的差异 ，编译器会天生差异的函数。然后再调用天生的函数。
函数模板的实例化

通过函数模板天生对应函数的过程叫做函数实例化。
当模板的参数只有一个时，却传入了差异范例的变量，编译器无法推导出T的范例，出现了推导错误。

2. template <class T>
3. void Swap(T& a, T& b)
4. {
5.         T c = a;
6.         a = b;
7.         b = c;
8. }
9. int main(){        int a, b;        a = 1; b = 2;        double c, d;        c = 0.0; d = 1.2;        Swap(a, c);        Swap(b, d);        cout << a << "  " << b << endl;        cout << c << "  " << d << endl;        return 0;}

复制代码

 然后我们就会发现报错了：

我们写的模板中是两个雷同的范例T，在实例化的过程中出现了推导标题不能天生对应的函数。
不重新界说模板参数的情况下，要办理这个标题有两种方法：
1.推导实例化，任然让编译器来推导出T的范例，通过逼迫范例转换来让传入的变量范例同等。

2. #define _CRT_SECURE_NO_WARNINGS 1
4. #include <iostream>
5. using namespace std;
7. template <class T>
8. T Add(const T& a, const T& b)
9. {
10.         return a + b;
11. }
13. int main()
14. {
15.         int a1 = 10, a2 = 5;
16.         double d1 = 11.2, d2 = 12.6;
17.         cout << Add(a1, (int)d1) << endl;
18.         cout << Add((double)a1, d1) << endl;
20.         return 0;
21. }

复制代码

2.表现实例化，不消编译器推导T的范例，直接指定T的范例。

2. template <class T>
3. T Add(const T& a, const T& b)
4. {
5.         return a + b;
6. }
8. int main()
9. {
10.         int a1 = 10, a2 = 5;
11.         double d1 = 11.2, d2 = 12.6;
12.         /*cout << Add(a1, (int)d1) << endl;
13.         cout << Add((double)a1, d1) << endl;*/
14.         cout << Add<int>(a1, d1) << endl;
15.         cout << Add<double>(a1, d1) << endl;
16.         return 0;
17. }

复制代码

这两种方法都可以办理推导标题，但是都对精度有影响。 而且当T不作参数时，只能使用表现实例化。
模板函数的匹配原则

当函数模板和现成的函数同时存在时，编译器会选择现成的函数。很简朴，有现成的为什么还要本身天生呢。

2. T Add(const T& a, const T& b)
3. {
4.         return a + b;
5. }
6. int Add(int a,int b)
7. {
8.         return (a + b) * 10;
9. }
11. int main()
12. {
13.         int a = 1;
14.         int b = 2;
15.         cout << Add(a, b) << endl;
16.        
17.         return 0;
18. }

复制代码

类模板 

2. #define _CRT_SECURE_NO_WARNINGS 1
4. #include <iostream>
5. using namespace std;
7. template <typename T>
8. class Stack
9. {
10. public:
11.         Stack(int n = 4)
12.                 :_array(new T[n])
13.                 , _capacity(n)
14.                 , _size(0)
15.         {
16.         }
17.         void push(const T& x)
18.         {
19.                 if (_capacity == _size)
20.                 {
21.                         T* tmp= new T[2 * _capacity];
22.                         memcpy(tmp, _array, _size * sizeof(T));
23.                         delete[] _array;
24.                         _array = tmp;
25.                         _capacity *= 2;
26.                 }
27.                 _array[_size++] = x;
28.         }
29.         ~Stack()
30.         {
31.                 delete[] _array;
32.                 _array = nullptr;
33.                 _capacity = _size = 0;
34.         }
35. private:
36.         T * _array;
37.         int _capacity;
38.         int _size;
39. };
41. int main()
42. {
43.         //类模板都是显示实例化
44.         Stack<int> str1;
45.         str1.push(1);
46.         str1.push(2);
47.         str1.push(3);
49.         return 0;
50. }

复制代码

底层： 

 
起首，类模板不能推导实例化。
 编译器不能自动推导出类中T的范例，这点和T作返回值不作参数的情况一样，编译器没有推理此中T范例的依据，以是不手动规定类的范例，就会报错。先比于c语言，用类模板的类可以储存差异范例的数据而不消重新在写一个Stack。

当界说和声明分离时，须要重新声明模板，而且99%的情况下，不能把界说和声明放到两个文件中。 

2. #define _CRT_SECURE_NO_WARNINGS 1
4. #include <iostream>
5. using namespace std;
7. template <typename T>
8. class Stack
9. {
10. public:
11.         Stack(int n = 4)
12.                 :_array(new T[n])
13.                 , _capacity(n)
14.                 , _size(0)
15.         {
16.         }
17.         void push(const T& x);
18.        
19.         ~Stack()
20.         {
21.                 delete[] _array;
22.                 _array = nullptr;
23.                 _capacity = _size = 0;
24.         }
25. private:
26.         T * _array;
27.         int _capacity;
28.         int _size;
29. };
30. template <typename T>//重新声明模板
31.    void Stack<T>::push(const T& x)
32. {
33.         if (_capacity == _size)
34.         {
35.                 T* tmp = new T[2 * _capacity];
36.                 memcpy(tmp, _array, _size * sizeof(T));
37.                 delete[] _array;
38.                 _array = tmp;
39.                 _capacity *= 2;
40.         }
41.         _array[_size++] = x;
42. }
43. int main()
44. {
45.         //类模板都是显示实例化
46.         Stack<int> str1;
47.         str1.push(1);
48.         str1.push(2);
49.         str1.push(3);
51.         return 0;
52. }

复制代码