1. 模板

模板就是建立通用的模具，大大提高复用性，C++中提供两种模板机制：函数模板和类模板

1.1 函数模板

函数模板就是建立一个通用函数,其函数返回值类型和形参类型不具体指定,用一个虚拟的类型来代表．

1.1.1 函数模板的语法

// 函数模板利用关键字template
template<Typename T>
// 函数声明或定义

// template -- 声明创建模板
// Typename -- 表明其后的符号是一种数据类型,可以用class代替
// T -- 通用的数据类型,名称可以替换,通常为大写字母

代码示例

#include<iostream>
using namespace std;

template<typename T>
void mySwap(T& a, T& b)
{
    
    
	T temp = a;
	a = b;
	b = temp;
}

void test()
{
    
    
	int a = 10;
	int b = 20;
	mySwap<int>(a, b);
	cout << "a = " << a　<< endl;
	cout << "b = " << b  << endl;
}

int main()
{
    
    
	test();
	system("pause");
	return 0;
}

1.1.2 函数模板的注意事项

使用函数模板有两种方式: 自动类型推导和显示指定类型

使用模板时必须确定出通用数据类型T,并且能推导出一致的类型

// 利用模板提供通用的交换函数
template<class T>
void mySwap(T& a, T& b)
{
    
    
	T temp = a;
	a = b;
	b = temp;
}

// 1. 自动类型推导.必须推导出一致的数据类型T,才可以使用
void test01()
{
    
    
	int a = 10;
	int b = 20;
	char c = 'c';
	mySwap(a, b); // 正确, 可以推导出一致的T
	// mySwap(a, c); // 错误, 推导不出一致的T类型
}
// 2. 模板必须要确定出T的数据类型才可以使用
template<class T>
void func()
{
    
    
	cout << "func 调用" << endl;
}
void test02()
{
    
    
	// func(); // 错误, 模板不能独立使用,必须确定出T的类型
	func<int>(); // 利用显示指定类型的方式,给T一个类型,才可以使用该模板
}

1.1.3 函数模板案例

案例描述:

利用函数模板封装一个排序函数,可以对不同数据类型数组进行排序
排序规则从大到小,排序算法为选择排序
分别利用char数组和int数组进行测试

// 交换的函数模板
template<typename T>
void mySwap(T& a, T& b)
{
    
    
	T temp = a; 
	a = b;
	b = temp;
}

template<class T>
// 利用选择排序,进行数组从大到小排序
void mySort(T arr[], int len)
{
    
    
	for(int i = 0;, i < len; i++)
	{
    
    
		max = i;
		for(int j = i+1; j < len; j++)
		{
    
    
			if(arr[max] < arr[j])
			{
    
    
				max = j;
			}
		}
		if(max != i)
		{
    
    
			mySort(arr[i], arr[max]);  // 如果最大数的下标不是i,交换两者
		}
	}
}

template<typename T>
void printArray(T arr[], int len)
{
    
    
	for(int i = 0; i < len; i++)
	{
    
    
		cout << arr[i] <<" ";
	}
	cout << endl;
}

void test01()
{
    
    
	// 测试char数组
	char charArr[] = "defgabc";
	int num = sizeof(charArr)/sizeof(char);
	mySort(charArr, num);
	printArray(charArr, num);
}

void test02()
{
    
    
	// 测试int数组
	int intArr = {
    
    7, 5, 8, 1, 3, 4,, 6, 2}
	int num = sizeof(charArr)/sizeof(int);
	mySort(intArr, num);
	printArray(intArr, num);
}

void main()
{
    
    
	system("pause");
	return 0;
}
// h g f e d c b a
// 8 7 6 5 4 3 2 1

1.1.4 普通函数与函数模板的区别

普通函数与函数模板的区别:

普通函数调用时可以发生自动类型转换(隐式类型转换)

函数模板调用时,如果利用自动类型推导,不会发生隐式类型转换 (如字符串转ASII码)

如果利用显示指定类型的方式,可以发生隐式类型转换

#include<iostream>
using namespace std;

// 普通函数
int myAdd01(int a , int b) 
{
    
    
	return a + b;
}

// 函数模板
template<class T>
T myAdd02(T a, T b) 
{
    
    
	return a + b;
}

// 使用函数模板时，如果用自动类型推导，不会发生自动类型转换，即隐式类型转换
void test_01()
{
    
    
	int a = 10;
	int b = 20;
	char c = 'c';

	cout << myAdd01(a, c) << endl;       // 正确, 将char类型'c'隐式转换为int类型 ASII码  c -- 99
	// cout << myAdd02(a, c) << endl;    // 报错,使用自动类型推导时,不会发生隐式类型转换 
	cout << myAdd02<int>(a, c) << endl; // 正确，如果用显示指定类型，可以发生隐式类型转换
}

int main() 
{
    
    
	test_01();
	system("pause");
	return 0;
}	
// 109
// 109

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

调用规则如下

如果函数模板和普通函数都能实现，优先调用普通函数

可以通过空模板参数列表来强制调用函数模板

函数模板也可以发生重载

如果函数模板可以产生更好的匹配，优先调用函数模板

代码示例

#include<iostream>;
using namespace std;

// 普通函数与函数模板的调用规则
void myPrint(int a, int b)
{
    
    
	cout << "调用普通函数" << endl;
}

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

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

void test_01() 
{
    
    
	// 1. 如果函数模板和普通函数都能实现，优先调用普通函数
	int a = 10;
	int b = 10;
	myPrint(a, b); // 调用普通函数

	// 2. 可以通过空模板参数列表来强制调用函数模板
	myPrint<>(a, b);

	// 3. 函数模板也可以发生重载
	int c = 30;
	myPrint(a, b, c);

	// 4. 如果函数模板可以产生更好的匹配，优先调用函数模板
	char c1 = 'a';
	char c2 = 'b';
	myPrint(c1, c2);
}

int main() 
{
    
     
	test_01();
	system("pause");
	return 0;
}
// 调用普通函数
// 调用模板
// 调用重载的模板
// 调用模板

1.2 类模板

类模板的作用: 建立一个通用类, 类中的成员数据类型可以不具体制定, 用一个虚拟的类型来代表

1.2.1 类模板的语法

// 类模板和函数模板语法极为相似,在声明模板template后面加类,此类称为类模板
template<typename T>
// 类

代码示例

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

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

void test_01() 
{
    
    
	// 指定NameType为string 类型 AgeType 为int 类型
	Person<string, int>P1("孙悟空", 999);
	P1.showPerson();
}

int main() 
{
    
    
	test_01();
	system("pause");
	return 0;
}
// name: 孙悟空 age: 999

1.2.2 类模板与函数模板的区别

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

类模板美欧自动类型推导的使用方式

类模板在模板参数列表中可以有默认参数

代码示例:

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

// 类模板和函数模板的区别主要有两点
// 1. 类模板没有自动类型推导的使用方式
// 2. 类模板在模板参数列表众可以有默认参数

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

// 1. 类模板没有自动类型推导的使用方式
void test_01() 
{
    
    
	// Person132 p('孙悟空', 1000); // 错误，类模板使用时，不可以用自动类型推导
	Person132<string, int> p("孙悟空", 1000); // 必须使用显示指定类型的方式，使用类模板
	p.showPerson();
}

// 2. 类模板在模板参数列表中可以有默认参数
void test_02() 
{
    
    
	Person132<string> p2("猪八戒", 999); // 可以制定默认参数
	p2.showPerson();
}
int main()
{
    
    
	test_01();
	test02();
	system("pause");
	return 0;
}
// name: 孙悟空 age: 1000
// name: 猪八戒 age: 999

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

类模板中成员函数和普通函数中成员函数的创建时机是有区别的:

普通类中的成员函数一开始就可以创建

类模板中的成员函数在调用时才创建

代码示例:

#include<iostream>
using namespace std;

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

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

template<class T>
class MyClass
{
    
    
public:
	T obj;
	// 类模板中的成员函数，并不是一开始就创建，而是在模板调用时在生成
	void fun1() {
    
     obj.showPerson_01(); }
	void fun2() {
    
     obj.showPerson_02(); }
};

void test_01()
{
    
    
	MyClass<Person_01> m;
	m.fun1();
	// m.fun2();  // 编译会出错,说明函数调用才会创建成员函数
}

int main() 
{
    
    
	test_01();
	system("pause");
	return 0;
}
// Person1 show

1.2.4 类模板对象做函数参数

类模板实例化出的对象, 有三种向函数传参的方式

指定传入的类型 — 直接显示对象的数据类型

参数模板化 — 将对象中的参数变为模板进行传递

整个类模板化 — 将这个对象类型模板化进行传递

代码示例:

#include<iostream>
using namespace std;

// 类模板对象做函数参数，共有三种传入方式
// 1. 指定传入的类型  --- 直接显示对象的数据类型
// 2. 参数模板化      --- 将对象中参数变为模板进行传递
// 3. 整个类模板化    --- 将这个对象类型模板化进行传递

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


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

// 2. 参数模板化
template<class T1, class T2>
void printPerson2(Person<T1 , T2> &p) 
{
    
    
	p.showPerson();
	cout << "T1的类型为： " << typeid(T1).name() << endl;
	cout << "T2的类型为： " << typeid(T2).name() << endl;
}
void test_02() 
{
    
    
	Person<string, int> p("孙悟空", 100);
	printPerson2(p);
}

// 3. 整个类模板化
template<class T>
void printPerson3(T& p) 
{
    
    
	cout << "T的类型为： " << typeid(T).name() << endl;
	p.showPerson();
}
void test_03()
{
    
    
	Person<string, int> p("唐僧", 100);
	printPerson3(p);
}

int main()
{
    
    
	test_01();
	test_02();
	test_03();
	system("pause");
	return 0;
}
// name: 孙悟空 age: 100
// name: 孙悟空 age: 100
// T1的类型为： class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >
// T2的类型为： int
// T的类型为： class Person<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,int>
// name: 唐僧 age: 100

1.2.5 类模板与继承

当类模板碰到继承时,需要注意以下几点:

如果父类是类模板, 子类需要指定出父类中T的数据类型

如果不指定, 编译器无法给子类分配内存

如果想灵活指定出父类中T的类型, 子类也需要变成类模板

代码示例:

#include<iostream>
using namespace std;

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

// class Son :public Base  //错误，c++编译需要给子类分配内存，必须知道父类中T的类型才可以向下继承
class Son :public Base<int> // 必须指定一个类型
{
    
    
};

void test_01()
{
    
    
	Son c;
}

// 类模板继承类模板，可以用T2指定父类中T类型
template<class T1, class T2>
class Son2 :public Base<T2>
{
    
    
public:
	Son2()
	{
    
    
		cout << typeid(T1).name() << endl;
		cout << typeid(T2).name() << endl;
	}
};
void test_02()
{
    
    
	Son2<int, char> c;
}

int main()
{
    
    
	test_01();
	test_02();
	system("pause");
	return 0;
}
// int
// char

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

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

代码示例:

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

// 类模板中成员函数类外实现
template<class T1, class T2>
class Person
{
    
    
public:
	// 成员函数类内声明
	Person(T1 name, T2 age);
	void showPerson();
public:
	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_01() 
{
    
    
	Person<string, int>p("Tom", 20);
	p.showPerson();
}

int main()
{
    
    
	test_01();
	system("pause");
	return 0;
}
// name: Tom age: 20

1.2.7 类模板分文件编写

存在的问题: 类模板中成员函数创建时机是在调用阶段,导致分文件编写时链接不到
解决方案:
方案一: 直接包含.cpp源文件
方案二: 将声明和实现写到同一个文件中,并更改名称为.hpp, hpp是约定的名称,并不是强制(主流做法)

代码示例, person.hpp中代码:

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

template<class T1, class T2>
class Person 
{
    
    
public:
	Person(T1 name, T2 age);
	void showPerson();
public:
	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;
}

类模板分文件编写中.cpp的代码

#include<iostream>
using namespace std;
// 方案一 包含cpp源文件
// include "person.cpp" // 在person.h中声明, person.cpp中实现
// 方案二 将声明和实现写到一起,文件后缀名改为.hpp
#include "person.hpp"
void test_01() 
{
    
    
	Person<string, int> p("Tom", 10);
	p.showPerson();
}
int main()
{
    
    
	test_01();
	system("pause");
	return 0;
}
// 姓名： Tom 年龄： 10

1.2.8 类模板与友元

全局函数在类内实现 — 直接在类内声明友元即可
全局函数在类外实现 — 需要提前让编译器知道全局函数的存在

代码示例:

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

// 全局函数类内实现 - 直接在类内声明友元即可
// 全局函数类外实现 - 需要提前让编译器知道全局函数的存在
template<class T1, class T2> class Person138;

template<class T1, class T2>
void printPerson2(Person<T1, T2> &p)
{
    
    
	cout << "类外实现 --- 姓名： " << p.m_Name << " 年龄：" << p.m_Age << endl;
}

template<class T1, class T2>
class Person
{
    
    
	// 1. 全局函数配合友元  类内实现
	friend void printPerson(Person<T1, T2> &p)
	{
    
    
		cout << " 姓名： " << p.m_Name << " 年龄：" << p.m_Age << endl;
	}
	// 2. 全局函数配合友元 类外实现
	// 需要加空模板参数列表
	// 类外实现需要让编译器提前知道这个函数的存在
	friend void printPerson2<>(Person<T1, T2>& p);

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

// 1. 全局函数在类内实现
void test_01()
{
    
    
	Person<string, int> p("Tom", 20);
	printPerson(p);
}

// 2. 全局函数在类外实现
void test_02()
{
    
    
	Person<string, int> p("Jerry", 30);
	printPerson2(p);
}

int  main()
{
    
    
	test_01();
	test_02();
	system("pause");
	return 0;
}
//  姓名： Tom 年龄：20
//  类外实现 --- 姓名： Jerry 年龄：30

导图

在这里插入图片描述

3.1 C++模板

1. 模板

1.1 函数模板

1.1.1 函数模板的语法

1.1.2 函数模板的注意事项

1.1.3 函数模板案例

1.1.4 普通函数与函数模板的区别

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

1.2 类模板

1.2.1 类模板的语法

1.2.2 类模板与函数模板的区别

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

1.2.4 类模板对象做函数参数

1.2.5 类模板与继承

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

1.2.7 类模板分文件编写

1.2.8 类模板与友元

导图

猜你喜欢