C++ 基础（5）模板

C++ 模板

一. 概念

模板就是实现代码重用机制的一种工具，它可以实现类型参数化，即把类型定义为参数，从而实现了真正的代码可重用性。模版可以分为两类，一个是函数模版，另外一个是类模版

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

二. 函数模板

2.1 语法

template<typename T>
void func()
{
    
    
}

说明： template是一个声明模板的关键字，表示声明一个模板，
关键字class，表面其后面的符号是一种数据类型，
T 可以包含基本数据类型，也可以包含自定义类型.，名称可以任意替换，通常为大写字母

2.2 案例

//交换整型函数
void swapInt(int& a, int& b) {
    
    
	int temp = a;
	a = b;
	b = temp;
}

//交换浮点型函数
void swapDouble(double& a, double& b) {
    
    
	double temp = a;
	a = b;
	b = temp;
}

//利用模板提供通用的交换函数
template<class T>
void swapT(T& a, T& b)
{
    
    
	T temp = a;
	a = b;
	b = temp;
}
int main()
{
    
    
	int a = 1;
	int b = 2;
	swapInt(a,b);
	cout << a << b << endl; // 21
	double c = 111.0;
	double d = 222.0;
	swapDouble(c, d);
	cout << c << d << endl; // 222111
	swapT(a,b);
	cout << a << b << endl; // 12
	swapT(c, d);
	cout << c << d << endl; // 111222
	return 0;
}

以上这案例类型T 自动类型推导 ，推导出了函数参数是 int类型，
也可以让T 显示指定类型，写法：

	swapT<int>(a, b);
	swapT<double>(c, d);

注意：如果是自动类型推导，不会发生隐式类型转换
如果显示指定类型，可以发生隐式类型转换

template<class T>
void swapT(T a, T b)
{
    
    
	T temp = a;
	a = b;
	b = temp;
}
int main()
{
    
    
	int a = 1;
	int b = 2;
	char c = 'c';
	double d = 222.0;
	swapT<int>(a, c);
	swapT<int>(a, d);
	swapT<int>(c, d);
	// swapT(a, d); // 自动类型推导，必须推导出一致的类型
	return 0;
}

2.3 注意事项

如果使用了自动类型推导，必须推导出一致的数据类型T,才可以使用：

template<class T>
void func()
{
    
    
	cout << "func 调用" << endl;
}
int main()
{
    
    
	// func(); //错误，模板不能独立使用，必须确定出T的类型
	func<int>(); //利用显示指定类型的方式，给T一个类型，才可以使用该模板
	return 0;
}

2.4 案例：利用模板封装一个数组排序的函数

template<class T>
void arrSort(T arr[])
{
    
    
	// 数组长度
	int len = sizeof(arr) / sizeof(arr[0]);
	for (int i = 0; i < len; i++)
	{
    
    
		for (int j = i + 1; j < len; j++)
		{
    
    
			if (arr[i] > arr[j])
			{
    
    
				T temp = arr[j];
				arr[j] = arr[i];
				arr[i] = temp;
			}
		}
	}
}

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

普通函数与函数模板可以发生重载
函数模板和普通函数如果都可以实现，优先调用普通函数
如果函数模板可以产生更好的匹配，优先调用函数模板
可以通过空模板参数列表<>来强制调用函数模板如：fun<>();
多个函数模板也可以发生重载

例：

void print1(int a, int b)
{
    
    
	cout << "普通函数 pringt 1 被调用了" << endl;
}

template<typename T>
void print1(T a, T b)
{
    
    
	cout << "函数模板 print 1 被调用了" << endl;
}

template<typename T>
void print1(T a, T b, T c)
{
    
    
	cout << "函数模板 print 2 被调用了" << endl;
}

int main() {
    
    
	int a = 10;
	int b = 20;

	print1(a, b); // 优先调用普通函数
	print1<>(a, b); //强制调用函数模板

	int c = 30;
	print1(a, b, c); //调用重载的函数模板

	char c1 = 'a';
	char c2 = 'b';
	print1(c1, c2); //优先调用函数模板
	return 0;
}

2.6 模板的局限性

局限性：

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

	template<class T>
	void func(T a, T b)
	{
    
     
    	a = b;
    }

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

扫描二维码关注公众号，回复： 12421298 查看本文章

template<class T>
bool f(T a, T b)
{
    
    
	return a > b;
}

在上述代码中，如果T的数据类型是自定义数据类型，也无法实现

因此C++为了解决这种问题，提供模板的重载，可以为这些特定的类型提供具体化的模板

class Person
{
    
    
public:
	Person(string name, int age)
	{
    
    
		this->name = name;
		this->age = age;
	}
	string name;
	int age;
};

//普通的函数模板
template<class T>
bool compare(T& a, T& b)
{
    
    
	return a == b;
}

// 以template<> 指定参数的模板
// 优先于普通的模板函数
template<> bool compare(Person& p1, Person& p2)
{
    
    
	return p1.name == p2.name && p1.age == p2.age;
}
int main() {
    
    
	int a = 10;
	int b = 20;
	//内置数据类型可以直接使用通用的函数模板
	bool res1 = compare(a, b);
	cout << res1 << endl;

	Person p1("海洋", 21);
	Person p2("海洋", 21);

	// 会调用具体化的模板
	bool res2 = compare(p1, p2);
	cout << res2 << endl;
	return 0;
}

三. 类模板

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

3.1 语法

示例：

template<typename T>
class Person 
{
    
    
public:
	Person(T name,int age)
	{
    
    
		this->name = name;
		this->age = age;
	}
private:
	T name;
	int age;
};

int main()
{
    
    
	// Person p1("haiyang",21); // 必须使用 显示指定类型的方式
	Person<string> p1("haiyang",21);
	return 0;
}

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

3.2 类模板与函数模板区别

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

类模板没有自动类型推导的使用方式
类模板在模板参数列表中可以有默认参数

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

类模板中的成员函数并不是一开始就创建的，在调用时才去创建

class Person1
{
    
    
public:
	void showPerson1()
	{
    
    
		cout << "Person1 show" << endl;
	}
};

class Person2
{
    
    
public:
	void showPerson2()
	{
    
    
		cout << "Person2 show" << endl;
	}
};

template<class T>
class TemplateClass
{
    
    
public:
	T obj;
	//类模板中的成员函数，并不是一开始就创建的，而是在模板调用时再生成
	void fun1() 
	{
    
    
		obj.showPerson1();
	}
	void fun2() 
	{
    
     
		obj.showPerson2();
	}
};
int main()
{
    
    
	TemplateClass<Person1> t;
	t.fun1();
	//m.fun2(); //编译期间会出错，说明函数调用才会去创建成员函数
	return 0;
}

3.4 类模板对象做函数参数

类模板对象做函数参数一共有三种传入方式：

指定传入的类型 — 直接显示对象的数据类型
参数模板化 — 将对象中的参数变为模板进行传递
整个类模板化 — 将这个对象类型模板化进行传递

//类模板
template<class NameType, class AgeType = int>
class Person
{
    
    
public:
	Person(NameType name, AgeType age)
	{
    
    
		this->name = name;
		this->age = age;
	}
	void showPerson()
	{
    
    
		cout << "name: " << this->name << " age: " << this->age << endl;
	}
public:
	NameType name;
	AgeType age;
};

//1.指定传入的类型
void printPerson1(Person<string, int>& p)
{
    
    
	p.showPerson();
}

//2.参数模板化
template <class T1, class T2>
void printPerson2(Person<T1, T2>& p)
{
    
    
	p.showPerson();
}

//3.整个类模板化
template<class T>
void printPerson3(T& p)
{
    
    
	p.showPerson();
}

3.5 类模板与继承

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

当子类继承类模板时，子类在声明的时候，要指定出父类中T的类型
如果不指定，编译器无法给子类分配内存
如果想灵活指定出父类中T的类型，子类也需变为类模板

template<class T>
class Base
{
    
    
	T t;
};
//1.指定一个类型 因为需要给子类分配内存空间，所以必须指定
class Son1 :public Base<int> 
{
    
    
};
//2. 类模板继承类模板
template<class T1, class T2>
class Son2 :public Base<T2> 
{
    
    
};
int main() 
{
    
    
	Son1 s;
	Son2<string,int> s;
	return 0;
}

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

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

//类模板中成员函数类外实现
template<class T1, class T2>
class Person {
    
    
public:
	Person(T1 name, T2 age);
	void showPerson();
public:
	T1 name;
	T2 age;
};
// Person类的构造函数类外实现
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age) {
    
    
	this->name = name;
	this->age = age;
}
//成员函数 类外实现
template<class T1, class T2>
void Person<T1, T2>::showPerson() {
    
    
	cout << this->name << this->age << endl;
}

int main()
{
    
    
	Person<string, int> p("haiyang", 21);
	p.showPerson();
	return 0;
}

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

问题：

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

解决：

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

3.7.1 编写.h头文件

template<class T1, class T2>
class Person {
    
    
public:
	Person(T1 name, T2 age);
	void printPerson();
public:
	T1 name;
	T2 age;
};

3.7.2 编写.cpp 实现

template<class T1,class T2>
Person<T1,T2>::Person(T1 name, T2 age)
{
    
    
	this->name = name;
	this->age = age;
}
template<class T1, class T2>
void Person<T1, T2>::printPerson()
{
    
    
	cout << this->name << this->age << endl;
}

3.7.2 测试代码

int main() {
    
    
	Person <string, int >p("haiyang", 21);
	p.printPerson();
	return 0;
}

运行结果：
在这里插入图片描述
提示两个无法解析的外部命令
这两个无法解析的外部命令是

	Person <string, int >p("haiyang", 21);
	p.printPerson();

这两行代码造成的，注释一行后就变成了一个无法解析的外部命令

3.7.3 原因

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

3.7.4 解决方案

直接包含.cpp源文件
在测试代码的文件里面直接包含 .cpp 文件，原来是包含的.h 头文件
在这里插入图片描述

将声明和实现写到一起，文件后缀名改为.hpp

template<class T1, class T2>
class Person {
    
    
public:
	Person(T1 name, T2 age);
	void printPerson();
public:
	T1 name;
	T2 age;
};
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age)
{
    
    
	this->name = name;
	this->age = age;
}

template<class T1, class T2>
void Person<T1, T2>::printPerson()
{
    
    
	cout << this->name << this->age << endl;
}

在这里插入图片描述

3.8 类模板与友元

3.8.1 友元函数在类内实现

template<class T1, class T2>
class Person
{
    
    
	// 友元函数
	friend void printPerson(Person<T1, T2> &p)
	{
    
    
		cout << p.name << p.age << endl;
	}
public:
	Person(T1 name, T2 age)
	{
    
    
		this->name = name;
		this->age = age;
	}
private:
	T1 name;
	T2 age;
};
int main() {
    
    
	Person <string, int >p("haiyang", 21);
	printPerson(p);
	return 0;
}

3.8.2 友元函数类外实现

// 3. 
template<class T1, class T2>
class Person;

template<class T1, class T2>
void printPerson(Person<T1, T2>& p) //2. 因为这里又依赖了 Person，需要将Person的声明放在上面
{
    
    
	{
    
    
		cout << p.name << p.age << endl;
	}
}


template<class T1, class T2>
class Person
{
    
    
	// 声明一个全局函数
	// 需要加上空模板参数列表<> ,告诉编译器 这是个类模板函数声明，不加就是 普通函数声明
	// 因为是类外实现的全局函数，需要让编译器知道这个函数的存在，所以将这个函数的实现放在上面
	friend void printPerson<>(Person<T1, T2>& p); 
	
public:
	Person(T1 name, T2 age)
	{
    
    
		this->name = name;
		this->age = age;
	}
private:
	T1 name;
	T2 age;
};

int main() {
    
    
	Person <string, int >p("haiyang", 21);
	printPerson(p);
	return 0;
}

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

四. 数组模板案例

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

可以对内置数据类型以及自定义数据类型的数据进行存储
将数组中的数据存储到堆区
构造函数中可以传入数组的容量
提供对应的拷贝构造函数以及operator=防止浅拷贝问题
提供尾插法和尾删法对数组中的数据进行增加和删除
可以通过下标的方式访问数组中的元素
可以获取数组中当前元素个数和数组的容量

第一步创建 .hpp 文件

template<class T>
class ArrTemplate
{
    
    
public:
	ArrTemplate(int capacity)
	{
    
    
		this->capacity = capacity;
		this->size = 0;
		this->arrPtr = new T[capacity];
	}
	ArrTemplate(const ArrTemplate & arr)
	{
    
    
		this->capacity = arr.capacity;
		this->size = arr.size;
		this->arrPtr = new T[arr.capacity];
		for (int i = 0; i < arr.size; i++)
		{
    
    
			this->arrPtr[i] = arr.arrPtr[i];
		}
	}
	ArrTemplate& operator=(const ArrTemplate & arr)
	{
    
    
		if (this->arrPtr != NULL)
		{
    
    
			delete[] this->arrPtr;
			this->size = 0;
			this->capacity = 0;
		}
		this->capacity = arr.capacity;
		this->size = arr.size;
		this->arrPtr = new T[arr.capacity];
		for (int i = 0; i < arr.size; i++)
		{
    
    
			this->arrPtr[i] = arr.arrPtr[i];
		}
	}

	~ArrTemplate()
	{
    
    
		if (this->arrPtr != NULL)
		{
    
    
			delete[] this->arrPtr;
			this->arrPtr = NULL;
		}
	}
private:
	T * arrPtr;
	int size;
	int capacity;
	
};

第二步
添加 api方法，实现自定义数组的功能

	// 尾插
	void addLast(const T& val)
	{
    
    
		if (this->capacity == this->size)
		{
    
    
			cout << "数组容量已满" << endl;
			return;
		}
		this->arrPtr[this->size] = val;
		this->size++;
	}
	// 尾删
	void removeLast()
	{
    
    
		if (this->size < 1)
		{
    
    
			cout << "数组为空" << endl;
			return;
		}
		this->arrPtr[this->size] = NULL;
		this->size--;
	}

	// 重写[] 运算符
	T & operator[](int index)
	{
    
    
		return this->arrPtr[index];
	}
	// 获取大小
	int getSize()
	{
    
    
		return this->size;
	}

	// 获取容量
	int getCapacity()
	{
    
    
		return this->capacity;
	}
	// 打印
	void print() 
	{
    
    
		if (this->size > 0)
		{
    
    
			for (int i = 0; i < this->getSize(); i++)
			{
    
    
				cout << this->arrPtr[i] << endl;
			}
		}
	}

C++ 基础（5） 模板