C++基础学习-类模板（八）

文章目录

1 函数模板基本使用
2 函数模板和普通函数的区别及调用规则
3 模板局限性
4 类模板
5 类模板做函数参数
6 类模板碰到继承的问题
7 类模板的类外成员函数实现
8 类模板的分文件编写问题以及解决
9 类模板碰到友元函数
10 类模板应用

1 函数模板基本使用

1.1 template <class/typename T> 告诉编译器紧跟的代码里出现T不要报错
1.2 mySwap(T &a， T &b)类型也需要传入，类型参数化
1.3 mySwap(a, b) 自动类型推导按照ab的类型来替换T
1.4 mySwap<int>(a,b) 显示指定类型
1.5 实例

#include<iostream>
using namespace std;

// 类型参数化 泛型编程 -- 模板技术
template <class T> // 告诉编译器 下面如果出现了T不要报错，T是一个通用的类型
// template <typename T> 等价于 template <class T>
void mySwap(T &a, T&b)
{
	T temp = a;
	a = b;
	b = temp;
}


void test()
{
	int a = 10;
	int b = 20;
	// 自动类型推导，必须有参数类型才可以推导
	mySwap(a, b);
	// 显示指定类型
	mySwap<int>(a, b);
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

	double c = 1.1;
	double d = 1.2;
	mySwap(c, d);
	cout << "c = " << c << endl;
}

int main()
{
	test();
	return EXIT_SUCCESS;
}

输出：

a = 10
b = 20
c = 1.2

2 函数模板和普通函数的区别及调用规则

2.1 区别
普通函数可以进行隐式类型转换模板不可以
2.2 调用规则
（1）C++编译器优先考虑普通函数
（2）可以通过空模板实参列表的语法限定编译器只能通过模板匹配
（3）函数模板可以像普通函数那样可以被重载
（4）如果函数模板可以产生一个更好的匹配，那么选择模板
2.3 实例

#include<iostream>
using namespace std;

template <class T>
void myPrint(T a, T b)
{
	cout << "模板函数调用" << endl;
}

template <class T>
void myPrint(T a, T b, T c)
{
	cout << "模板调用的myPrint" << endl;
}

void myPrint(int a, int b)
{
	cout << "普通函数调用" << endl;
}

void test()
{
	int a = 10;
	int b = 20;
	int c = 30;
	// 1 如果出现重载，优先使用普通函数调用，如果没有实现，出现错误
	myPrint(a, b);
	// 2 如果想强制调用模板，那么可以使用空参数列表
	myPrint<>(a, b);
	// 3 函数模块可以发生重载
	myPrint(a, b, c);
	// 4 如果函数模板可以产生更好的匹配，那么优先调用函数模板
	char c1 = 'c';
	char d = 'd';
	
	myPrint(c1, d);

}

int main()
{
	test();

	return EXIT_SUCCESS;
}

输出：

普通函数调用
模板函数调用
模板调用的myPrint
模板函数调用

2.4 模板的机制
（1）模板不是万能的，不能通用所有的数据类型
（2）模板不能直接调用，生成后的模板函数才可以调用
（3）二次编译，第一次对模板进行编译，第二次对替换T类型后的代码进行编译
比如说下面：

// 函数模板
template <class T>
void myPrint(T a, T b, T c)
{
	cout << "模板调用的myPrint" << endl;
}
// 如果这时传递进来int类型数据,通过函数模板生成如下,也就是说通过模板生成的函数，叫模板函数
//void myPrint(int a, int b, int c)
//{...}

3 模板局限性

3.1 模板不能解决所有的类型
3.2 如果出现不能解决的类型，可以通过第三代具体化来解决问题
3.3 template<> 换回值函数名<具体类型> (参数)

#include<iostream>
using namespace std;

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

template <class T>
bool myCompare(T &a, T &b)
{
	if (a == b)
	{
		return true;
	}
	return false;
}

// 通过具体化自定义类型，解决上诉问题
// 如果具体化能够优先匹配，那么就选择具体化
// 语法 template<>换回值 函数名<具体类型>(参数)
template<> 
bool myCompare<Person>(Person &a, Person &b)
{
	if(a.m_Age == b.m_Age )
	{
		return true;
	}
	return false;

}

void test()
{
	int a = 10;
	int b = 20;
	int ret = myCompare(a, b);
	cout << "ret = " << ret << endl;
	Person p1("Tom", 10);
	Person p2("Jerry", 20);
	int ret2 = myCompare(p1, p2);
	cout << "ret = " << ret2 << endl;
}

int main()
{
	test();

	return EXIT_SUCCESS;
}

输出：

ret = 0
ret = 0

4 类模板

4.1 写法template<T…> 紧跟着是类
4.2 与函数模板区别，可以有默认类型参数
4.3 函数模板可以进行自动类型推导，而类模板不可以
4.4 实例

#include<iostream>
#include<string>
using namespace std;

// 类模板
template <class NameType,class AgeType=int> // 类模板可以有默认类型
class Person
{
public:
	Person(NameType name, AgeType age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	void showPerson()
	{
		cout << "姓名：" << this->m_Name << "年龄:" << this->m_Age << endl;
	}
	NameType m_Name;
	AgeType m_Age;
};

void test()
{
	// 自动类型推导，类模板不支持
	// Person p("孙悟空"，100);
	// 显示指定类型
	Person<string, int>p("孙悟空", 100);
	p.showPerson();
}

int main()
{
	test();

	return EXIT_SUCCESS;
}

输出：

姓名：孙悟空年龄:100

5 类模板做函数参数

5.1 三种方式
（1）显示指定类型
（2）参数模板化
（3）整体模板化
5.2 查看类型的名称

typeid(类型).name(）

5.3 实例

#include<iostream>
#include<string>
using namespace std;

template <class NameType,class AgeType=int>
class Person
{
public:
	Person(NameType name, AgeType age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}

	void showPerson()
	{
		cout << "姓名：" << this->m_Name << "年龄" << this->m_Age << endl;
	}

	NameType m_Name;
	AgeType m_Age;
};

// 1 指定传入类型
void doWork(Person<string, int>&p)
{
	p.showPerson();
}
void test()
{
	Person<string, int>p("MT", 10);
	doWork(p);
}

// 2 参数模板化
template<class T1,class T2>
void doWork2(Person<T1, T2>&P)
{
	// 如何查看类型
	cout << typeid(T1).name() << endl;
	P.showPerson();
}
void test02()
{
	Person<string, int> p("小王", 18);
	doWork2(p);
}


// 3 整体模板化
template <class T>
void doWork3(T &p)
{
	cout << typeid(T).name() << endl;
	p.showPerson();
}

void test03()
{
	Person<string, int> p("小张", 19);
	doWork3(p);
}

int main()
{
	test();
	test02();
	test03();

	return EXIT_SUCCESS;
}

输出：

姓名：MT年龄10
class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >
姓名：小王年龄18
class Person<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,int>
姓名：小张年龄19

6 类模板碰到继承的问题

6.1 基类如果是模板类，必须让子类告诉编译器基类中的T到底是什么类型
6.2 如果不告诉，那么无法分配内存，编译不过
6.3 利用参数列表class Child:public Base告诉基类中T是什么类型
6.4 实例

#include<iostream>
using namespace std;

template <class T>
class Base
{
public:
	T m_A;
};
// child继承Base必须告诉base中的T的类型，否则T无法分配内存
class Child :public Base<int>
{

};

// child2也是模板类
template<class T1,class T2>
class Child2 :public Base<T2>
{
public:
	Child2()
	{
		cout << typeid(T1).name() << endl;
		cout << typeid(T2).name() << endl;
	}

	T1 m_B;
};

void test()
{
	Child2<int, double>child;
}

int main()
{
	test();
	return EXIT_SUCCESS;
}

输出：

int
double

7 类模板的类外成员函数实现

#include<iostream>
#include<string>
using namespace std;

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

	void showPerson();

	T1 m_Name;
	T2 m_Age;
};

// 类外实现成员函数
template <class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age)
{
	this->m_Name = name;
	this->m_Age = age;
}

template <class T1,class T2>
void Person<T1, T2>::showPerson()
{
	cout << "姓名:" << this->m_Name << "年龄:" << this->m_Age << endl;
}

void test()
{
	Person <string,int>p1("MT", 10);
	p1.showPerson();
}
int main()
{
	test();

	return EXIT_SUCCESS;
}

输出：

姓名:MT年龄:10

8 类模板的分文件编写问题以及解决

8.1 .h .cpp分别写声明和实现
8.2 但是由于类模板的成员函数运行阶段才去创建，导致包含.h头文件，不会创建函数的实现，就无法外部命令
8.3 解决方案包含.cpp文件（不推荐）
8.4 不要进行分文件编写，写到同一个文件中，进行声明和实现，后缀名改为.hpp，这是约定俗成。
8.5 实例
下面演示.h.cpp分别写声明和实现
主文件：

#include "Person.h"

int main()
{
	Person<string, int>p("小王",10);
	p.showPerson();

	return EXIT_SUCCESS;
}

Person.h声明文件：

#pragma once
#include<iostream>
#include<string>
using namespace std;

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

	void showPerson();

	T1 m_Name;
	T2 m_Age;
};

Person.cpp实现文件：

#include "Person.h"

template<class T1,class T2>
Person<T1, T2>::Person(T1 name, T2 age)
{
	this->m_Age = age;
	this->m_Name = name;
}

template<class T1,class T2>
void Person<T1, T2>::showPerson()
{
	cout << "姓名:" << this->m_Name << "年龄:" << this->m_Age << endl;
}

这样看是没有错误，其实是编译不通过的。
修改方案一（不推荐）：
将主文件中包含的.h文件换成.cpp文件。因为在.cpp文件中有包含了.h文件还有模板成员函数的实现。
修改方案二（推荐）：
将主文件中的.h文件改为.hpp文件。其实就是将原来的实现的文件和声明放在一个文件中，改名为.hpp文件。
如下：

#pragma once
#include<iostream>
#include<string>
using namespace std;

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

	void showPerson();

	T1 m_Name;
	T2 m_Age;
};


template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age)
{
	this->m_Age = age;
	this->m_Name = name;
}

template<class T1, class T2>
void Person<T1, T2>::showPerson()
{
	cout << "姓名:" << this->m_Name << "年龄:" << this->m_Age << endl;
}

9 类模板碰到友元函数

9.1 友元函数类内实现
9.2 friend void printPerson(Person<T1,T2>&P)
9.3 实例

#include<iostream>
#include<string>
using namespace std;

template<class T1,class T2>
class Person
{
	// 友元函数类内实现
	friend void printPerson(Person<string,int>&p)
	{
		cout << "姓名:" << p.m_Name << "年龄:" << p.m_Age <<endl;
	}

public:
	Person(T1 name, T2 age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	

private:
	T1 m_Name;
	T2 m_Age;
};

void test()
{
	Person<string, int> p("Tom", 10);
	printPerson(p);
}

int main()
{
	test();
	return EXIT_SUCCESS;
}

输出：

姓名:Tom年龄:10

9.4 友元函数类外实现
friend void printPerson<>(Person<T1,T2>&P);没有<>普通函数声明加上<>模板函数声明
让编译器看到函数并且看到这个Person类型

#include<iostream>
#include<string>
using namespace std;

// 让编译器提前看到printPerson声明
// 让编译器看到Person类的声明
template<class T1, class T2> class Person;
template<class T1,class T2> void printPerson(Person<T1, T2>&p);

template<class T1,class T2>
class Person
{
	//friend void printPerson(Person<string, int>&p); // 普通函数 声明
	// 利用空参数列表 告诉编译器 模板函数声明 
	friend void printPerson<>(Person<string, int>&p);

public:
	Person(T1 name, T2 age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	

private:
	T1 m_Name;
	T2 m_Age;
};
// 模板函数实现
template<class T1,class T2>
void printPerson(Person<T1, T2>&p)
{
	cout << "姓名:" << p.m_Name << "年龄:" << p.m_Age << endl;
}

void test()
{
	Person<string, int> p("Tom", 10);
	printPerson(p);
}

int main()
{
	test();
	return EXIT_SUCCESS;
}

10 类模板应用

MyArray.hpp

#pragma once
#include<iostream>
#include<string>
using namespace std;
template<class T>
class MyArray
{
public:
	explicit MyArray(int capacity) // 防止隐式类型转换 防止MyArray arr = 10;写法
	{
		this->m_Capacity = capacity;
		this->m_Size = 0;
		this->pAddress = new T[this->m_Capacity];  
	}

	MyArray(const MyArray &array)
	{
		this->m_Capacity = array.m_Capacity;
		this->m_Size = array.m_Size;
		this->pAddress = new T[this->m_Capacity];
		for (int i = 0; i < m_Size; i++)
		{
			this->pAddress[i] = array[i];
		}
	}

	~MyArray()
	{
		if (this->pAddress != NULL)
		{
			delete[] this->pAddress;
			this->pAddress = NULL;
		}
	}

	// 赋值操作符重载
	MyArray &operator=(MyArray arr)
	{
		// 先判断原始数据，有就清空
		if (this->pAddress != NULL)
		{
			delete[] this->pAddress;
			this->pAddress = NULL;
		}

		this->m_Capacity = array.m_Capacity;
		this->m_Size = array.m_Size;
		this->pAddress = new T[this->m_Capacity];
		for (int i = 0; i < m_Size; i++)
		{
			this->pAddress[i] = array[i];
		}
	}
	//[]重载
	T & operator[](int index)
	{
		return this->pAddress[index];
	}

	// 尾插法
	void push_Back(T val)
	{
		this->pAddress[this->m_Size] = val;
		this->m_Size++;
	}
	// 获取大小
	int getSize()
	{
		return m_Size;
	}
	// 获取容量
	int getCapacity()
	{
		return this->m_Capacity;
	}

private:
	T *pAddress; // 指向堆区指针
	int m_Capacity;
	int m_Size;
};

主文件

#include"MyArray.hpp"

// 输出int类型数组
void printInArray(MyArray<int>&array)
{
	for (int i = 0; i < array.getSize(); i++)
	{
		cout << array[i] << endl;
	}
}

class Person
{
public:
	Person() 
	{
		cout << "默认构造" << endl;
	}
	Person(string name, int age)
	{
		this->m_Age = age;
		this->m_Name = name;
	}
	string m_Name;
	int m_Age;
};

// 输出Person类型数组
void printPersonArray(MyArray<Person>& array)
{
	for (int i = 0; i < array.getSize(); i++)
	{
		cout << "姓名：" << array[i].m_Name << " 年龄：" << array[i].m_Age << endl;
	}
}

int main()
{
	MyArray <int>arr(10);
	for (int i = 0; i < 10; i++)
	{
		arr.push_Back(i + 100);
	}
	printInArray(arr);

	Person p1("A", 10);
	Person p2("B", 12);
	Person p3("C", 14);
	Person p4("D", 15);

	cout << "****************" << endl;
	// 在创建MyArray时，调用Person类的构造函数
	MyArray<Person>arr2(10);
	cout << "*******" << endl;
	arr2.push_Back(p1);
	arr2.push_Back(p2);
	arr2.push_Back(p3);
	arr2.push_Back(p4);

	printPersonArray(arr2);

	return EXIT_SUCCESS;
}

输出：

100
101
102
103
104
105
106
107
108
109
****************
默认构造
默认构造
默认构造
默认构造
默认构造
默认构造
默认构造
默认构造
默认构造
默认构造
*******
姓名：A 年龄：10
姓名：B 年龄：12
姓名：C 年龄：14
姓名：D 年龄：15