C++ 中的 模板类 简介

---

前言

这一章主要讲类模板，包括它的主要用法和作用，简单写了一下和普通类的异同。
本文主要为学习心得笔记，如有纰漏，欢迎指正

---

一、类模板简介

与模板函数相同，若想要将类中的某个数据类型抽象化，在使用是再指定需要的数据类型，就需要使用模板类来实现。

定义：

template<class T>		//class 可以用typename替换
class 类名
{
	//...
};
1
2
3
4
5

与函数模板的区别

1. 类模板一般情况下无法自动类型推导的调用方式
2. 类模板在模板参数列表可以有默认参数，写法：

template<class T = 数据类型>
1

3. 类模板在有默认参数类型时，可以发生隐式类型转化
   例：

//有默认参数类型的类模板
template<class NameT, class IdT = int>
class Person1
{
	NameT name;
	IdT id;
public:
	Person1(NameT name, IdT id)
	{
		this->name = name;
		this->id = id;
	}
	void myPrint()
	{
		cout << name << endl;
		cout << id << endl;
	}
};

void test1()
{
	//错误用法，没有传入参数类型
	//Person1<> p("gzy", 10);	
	//Person1 p("gzy", 10);	
	
	//调用有默认参数类型的类模板
	Person1<string> p("gzy", 'a');	//会发生隐式类型转化
	Person1<string, char> p1("gzy", 'a');
	p.myPrint();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

类模板内函数的创建时机

• 普通类内的成员函数在编译时就会创建，类模板中的成员函数在调用时才会被创建，也就是说在主动调用前，编译器都看不到类模板的成员函数的内容。
• 类模板中的成员函数，里面写的东西只要语法正确，就会被编译通过，不会进行数据类型的判断
• 例：比如你类内函数的功能是对值类型数据进行数学运算，但是你传入一个数组类型，这时只要你不主动调用该函数，该函数将不会被编译器识别并报错。

二、类模板的各种应用

1.类模板对象做函数参数

• 共三种传参方式：

1. 指定类型传入
   将所有模板类用到的泛型逐个写入参数列表

void printPerson1(Person<string, int> &p){}
1

2. 参数模板化
   将函数模板化，参数列表用泛型表示即可

template<class T1, class T2>
void printPerson2(Person<T1, T2> &p){}
1
2

3. 整个类模板化
   将整个类抽象成一个模板

template<class T>
void printPerson3(T & p){}
1
2

2.类模板的继承

如果父类是一个类模板，则子类在继承时必须指定父类T的类型

1. 第一种方法，继承时指定类型

	template<class T> 
	class Base 
	{ 
		T m; 
	};

	//可以直接尖括号跟后面
	class Son : public Base <int> {}
1
2
3
4
5
6
7
8

2. 第二种方法，将子类也变为模板，这样可以灵活指定父类类型

	template<class T> 
	class Base 
	{ 
		T m; 
	};
	
	template<class T>
	class Son : public Base<T> {}
1
2
3
4
5
6
7
8

3.类模板中成员函数类外实现

1. 构造函数的类外实现：
   相比普通构造函数类外实现，需要加上template和参数列表，作用域之后需要加上参数列表中的参数，这样才能识别是该类的函数。

template<class NameT, class IdT>
class Person
{
	NameT name;
	IdT id;
public:
	Person(NameT name, IdT id);
};

//构造函数类外实现：
template<class T1, class T2>
Person<T1, T2>::Person(){}
1
2
3
4
5
6
7
8
9
10
11
12

• 成员函数的类外实现
  道理都差不多，也是必须加上template和参数列表，作用域后跟参数列表

template<class T1, class T2>
void Person<T1, T2>::func(){}
1
2

4.类模板的分文件编写

• 问题：类模板中的成员函数创建时机是在调用阶段，导致分文件: 编写时链接不到。
• 分文件：分为(.h)(.cpp)两个文件，分别存放声明和实现
• 由于函数在调用时才会被创建，所以分文件操作后，运行会导致找不到函数的实现，即找不到cpp文件中的内容。

1. 解决方法1：
   直接包含.cpp源文件，include时将"xxxx.h"改为"xxxx.cpp"即可
2. 解决方法2：
   将声明和实现写在同一个文件，后缀名改为.hpp (hpp是约定名称，并非强制)，调用同样调用"xxxx.hpp"

注：后面案例会写

• 类模板的友元函数：
  最好在类内实现，类外实现比较繁琐，不建议写类外实现

注：类内成员函数加上friend关键字后就会变为全局函数

---

三、模拟实现模板类

注：这里写的功能比较杂，只作为参考，练习使用。

• 以下内容均包含在 “myVector.hpp” 文件中

#pragma once
#include 
#include 
using namespace std;

template<class T>
class myVector
{
	T* arr;
	int capacity = 4;
	int count;
public:
	/*四个构造函数*/
	myVector();
	myVector(int capacity);
	myVector(int capacity, T ele);
	myVector(const myVector& p);

	/*析构函数*/
	~myVector();

	/*重载运算符*/
	myVector& operator= (const myVector& p);

	/*尾插*/
	void push_back(const T& val);

	/*尾删*/
	void pop_back();

	/*重载[]*/
	T& operator[] (int index);

	/*打印*/
	void print();
};

template<class T>
myVector<T>::myVector()
{
	capacity = 4;
	arr = new T[4];
	count = 0;
}

template<class T>
myVector<T>::myVector(int capacity)
{
	this->capacity = 4;
	while (this->capacity < capacity)
	{
		this->capacity <<= 1;
	}
	arr = new T[this->capacity];
	count = capacity;
}

template<class T>
myVector<T>::myVector(int capacity, T ele)
{
	while (this->capacity < capacity)
	{
		this->capacity <<= 1;
	}
	arr = new T[this->capacity];
	count = capacity;
	for (int i = 0; i < count; i++)
	{
		arr[i] = ele;
	}
}

template<class T>
myVector<T>::myVector(const myVector& p)
{
	*this = p;	//调用重载的 = 运算符
}

template<class T>
myVector<T>::~myVector() 
{
	if (arr != nullptr)
	{
		delete[] arr;
		arr = nullptr;
	}
	capacity = 0;
	count = 0;
}

template<class T>
myVector<T>& myVector<T>::operator= (const myVector& p)
{
	myVector<T>::~myVector();	//可以手动调用析构函数
	count = p.count;
	capacity = p.capacity;
	arr = new T[capacity];
	copy(p.arr, p.arr + count, arr);
	return *this;
}

template<class T>
void myVector<T>::push_back(const T& val)
{
	if (capacity <= count)	//扩容
	{
		capacity <<= 1;
		T* newArr = new T[capacity];
		copy(arr, arr + count, newArr);
		delete arr;
		arr = newArr;
	}
	arr[count] = val;
	count++;
}

template<class T>
void myVector<T>::pop_back()
{
	count -= (count > 0 ? 1 : 0);
}

template<class T>
T& myVector<T>::operator[] (int index)
{
	return arr[index];		// 使用[]来改变数值
}


template<class T>
void myVector<T>::print()
{
	for (int i = 0; i < count; i++)
	{
		cout << arr[i] << endl;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

---

总结

这一章主要记录模板类的学习，模板类的使用注意事项。