wen 编程最新 2024-01-31

01章-模板

1 模板

1.1 模板的概念

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

1.2 函数模板

C++另一种编程思想称为泛型函数，主要利用的技术就是模板
C++提供两种模板机制：函数模板和类模板

1.2.1 函数模板语法

模板函数作用：

建立一个通用函数，其函数返回值类型和形参类型可以不具体指定，用一个虚拟的类型来代表

语法：

template<typename T>
函数声明或定义

解释：

template — 声明创建模板

typename — 表面其后面的符号是一种数据类型，可以用class代替

T — 通用的数据类型，名称可以替换，通常为大写字母

示例；

#include<iostream>
using namespace std;

//函数模板

//两个整数交换函数
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;
}

void test01()
{
	int a = 10;
	int b = 20;
	swapInt(a, b);
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

	double c = 1.1;
	double d = 2.2;
	swapDouble(c, d);
	cout << "c = " << c << endl;
	cout << "d = " << d << endl;
}

//函数模板
template <typename T>//声明一个模板告诉编译器后面代码中紧跟着的T不要报错，T是一个通用的数据类型
void mySwap(T& a, T& b)
{
	T temp = a;
	a = b;
	b = temp;
}

void test02()
{
	int a = 10;
	int b = 20;

	//1、自动类型推导
	mySwap(a, b);

	//2、显示指定类型
	mySwap<int>(a, b);
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
}

int main()
{
	test01();

	test02();

	system("pause");
	return 0;
}

1.2.2 函数模板注意事项

注意事项：

自动类型推导，必须推导出一致的函数类型T，才可以使用
模板必须要确定出T的数据类型，才可以使用

示例：

#include<iostream>
using namespace std;

//函数模板注意事项

//template<typename T> // typename可以替换成calss

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);//正确
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

	//mySwap(a, c);//报错,无法推导出一致的数据类型

}

//2、模板必须要确定出T的数据类型，才可以使用
template<class T>
void func()
{
	cout << "func 调用" << endl;
}

void test02()
{
	func<int>();//随便给一个数据类型就能调用func模板函数了
}

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

1.2.3 函数模板案例

案例描述：

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

示例：

#include <iostream>
using namespace std;

//实现通用 对数组进行排序的函数
//规则 从大到小
//算法 选择
//测试 char 数组，int 数组

//交换函数模板
template<class 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++)
	{
		int max = i;//认定最大值下标
		for (int j = i + 1; j < len; j++)
		{
			//认定的最大值比遍历出的数值要小，说明j下标的元素才是真正的最大值
			if (arr[max] < arr[j])
			{
				max = j;//更新最大值下标
			}
		}
		if (max != i)
		{
			//交换max和i元素
			mySwap(arr[max], arr[i]);
		}
	}
}

//打印数组的模板
template<class T>
void printArray(T arr[], int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << "arr中的第" << i << "元素 = " << arr[i] << endl;
	}
}
void test01()
{
	//测试char数组
	char charArr[] = "badcfe";
	
	int num = sizeof(charArr) / sizeof(char);
	mySort(charArr, num);
	printArray(charArr, num);

}

void test02()
{
	//测试int数组
	int intArr[] = { 7,5,1,3,10,2,4,7,9 };

	int num = sizeof(intArr) / sizeof(int);

	mySort(intArr, num);
	printArray(intArr, num);
}

int main()
{
	test01();

	test02();

	system("pause");
	return 0;
}

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

普通函数与函数模板区别：

普通函数调用时可以发生自动类型转换（隐式类型转换）
函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
如果利用显示指定类型的方式，可以发生隐式类型转换

示例：

#include <iostream>
using namespace std;

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

//1、普通函数调用可以发生隐式类型转换
//2、函数模板 用自动类型推导，不可以发生隐式类型转换
//3、函数模板 用显示指定类型，可以发生隐式类型转换

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

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

void test01()
{
	int a = 10;
	int b = 20;

	char  c = "c"; //c - 99

	cout << myAdd01(a, c) << endl;

	//自动类型推导
	//cout << myAdd02(a, c) << endl;//报错，函数模板不可以发生隐式类型转换

	//显示指定类型
	cout << myAdd02<int>(a, c) << endl;//明确类型，正确
}

int main()
{
	test01();

	system("pause");
	return 0;
}

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

调用规则如下：

如果函数模板和普通函数可以实现，优先调用普通函数
可以通过空模板参数列表来强调函数模板
函数模板也可以发生重载
如果函数模板可以产生更好的匹配优先调用函数模板

示例：

#include<iostream>
using namespace std;

//普通函数与函数模板调用规则
//1、如果函数模板和普通函数都可以调用，优先调用普通函数
//2、可以通过空模板参数列表 强制调用 函数模板
//3、函数模板可以发生函数重载
//4、如果函数模板可以产生更好的匹配，优先调用函数模板

void myPrint(int a, int b)//如果只有声明，没有函数实现，就会报错，还是优先调用普通函数
{
	cout << "调用普通函数" << endl;
}

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

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

void test01()//优先调用普通函数
{
	int a = 10;
	int b = 10;
	myPrint(a, b);//调用普通函数

	//通过空模板的参数列表，强制调用函数模板
	myPrint<>(a, b);//调用函数模板

	myPrint(a, b, 100);//调用重载函数模板

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

}

int main()
{
	test01();

	system("pause");
	return 0;
}

总结：既然提供了函数模板，最好就不要提供普通函数了，容易产生二义性，实际开发中这样子意义不大。

1.2.6 模板的局限性

局限性：

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

例如

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

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

再例如

template<class T>
void f(T a, T b)
{
    if(a > b){...}
}

在上述代码中，如果T的数据类型传入的是像Person的自定义数据类型，也是无法正常运行的，

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

示例：

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

//模板的局限性
//模板并不是万能的，有些特定的数据类型，需要用具体化的方式做实现

//对比两个数据类型是否相等函数

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

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

//利用具体化的Person的版本实现代码，具体化优先调用
template<> bool myCompare(Person& p1, Person& p2)
{
	if (p1.m_Age == p2.m_Age && p1.m_Name == p2.m_Name)
	{
		return true;
	}
	else
	{
		return false;
	}
}

void test01()
{
	int a = 10;
	int b = 20;

	bool ret = myCompare(a, b);

	if (ret)
	{
		cout << "a == b" << endl;
	}
	else
	{
		cout << "a != b" << endl;	
	}
}

void test02()
{
	Person p1("Tom", 10);
	Person p2("Tom", 10);

	bool ret = myCompare(p1, p2);

	if (ret)
	{
		cout << "p1 == p2" << endl;
	}
	else
	{
		cout << "p1 != p2" << endl;
	}

}

int main()
{
	test01();
	
	test02();

	system("pause");
	return 0;
}

总结：

利用具体化的模板，可以解决自定义类型的通用化
学习模板并不是为了写模板，而是在STL能够运用系统提供的模板

1.3 类模板

1.3.1 类模板语法

类模板作用：

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

语法：

template<typname T>
类

解释：

template — 声明创建模板

typename — 表明其后面的符号是一种数据类型，可以用class代替

T — 通用的数据类型，名称可以替换，通常为大写字母

示例：

#include<iostream>
#include<string>
using namespace std;
//类模板
template<class NameType, class AgeType>

class Person
{
public:
	Person(NameType name, AgeType age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	NameType m_Name;
	AgeType m_Age;
	void showPerson()
	{
		cout << "name: " << this->m_Name << " age: " << this->m_Age << endl;
	}
};

void test01()
{
	Person<string, int>p1("孙悟空", 999);
	p1.showPerson();
}

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

1.3.2 类模板与函数模板区别

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

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

示例：

#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;
	}
	NameType m_Name;
	AgeType m_Age;
	void showPerson()
	{
		cout << "name: " << this->m_Name << " age: " << this->m_Age << endl;
	}
};

//1、类模板没有自动类型推导使用方式
void test01()
{
	//Person p("孙悟空",999)//错误，无法用自动类型推导
	Person<string, int>p("孙悟空", 999);
	p.showPerson();
}
//2、类模板在模板参数列表中可以有默认参数
void test02()
{
	Person<string>p("猪八戒", 1000);
	p.showPerson();
}

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

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

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

普通类中的成员函数一开始就可以创建
类模板中的成员函数在调用时才创建

示例

#include<iostream>
using namespace std;

//类模板中成员函数创建时机
//类模板中成员函数在调用时才去创建

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

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

template<class T>
class MyClass
{
public:
	T obj;

	//类模板中的成员函数//是在 被调用时候才会创建的，需要确认是什么成员函数类型之后才能被调用。不然调用不出来。
	void func1()
	{
		obj.showPerson1();
	}
	void func2()
	{
		obj.showPerson2();
	}
};

void test01()
{
	MyClass<Pesrson1> m;
	m.func1();
	//m.func2();
}

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

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

1.3.4 类模板对象做函数参数

学习目标：

类模板实例化出的对象，向函数传参的方式

一共有三种传入方式：

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

示例：

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

//类模板对象做函数参数

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

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

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

void test01()
{
	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 test02()
{
	Person<string, int>p("猪八戒", 1000);
	printPerson2(p);
}
//3、整个类模板化
template<class T>
void printPerson3(T& p)
{
	p.showPerson();
}

void test03()
{
	Person<string, int>p("唐僧", 30);
	printPerson3(p);
}

int main()
{
	test01();
	test02();
	test03();
	system("pause");
	return 0;
}

总结：

通过类模板创建的对象，可以有三种方式向函数中进行传参
比较广泛使用的方式是指定传入类型

1.3.5 类模板与继承

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

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

示例：

#include<iostream>
using namespace std;

//类模板与继承
template<class T>
class Base
{
	T m;
};

//class Son :public Base//错误，必须知道父类中的T类型，才能继承子类
class Son:public Base<int>
{

};

void test01()
{
	Son s1;
}

//如果想要灵活的指定父类中T的类型，子类也需要边类模板
template<class T1, class T2>
class Son2 :public Base<T2>
{
	T1 obj;
};

void test02()
{
	Son2<int, char>S2;

}

int main()
{
	test01();

	test02();
	system("pause");
	return 0;
}

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

学习目标：能够掌握类模板中的成员函数类外实现

示例：

#include<iostream>
#include<string>
using namespace std;
//类模板成员函数类外实现
template<class T1, class T2>
class Person
{
public:
	Person(T1 name, T2 age);
//	Person(T1 name, T2 age)
//	{
//		this->m_Name = name;
//		this->m_Age = age;
//	}
	
	void showPerson();
	//{
	//	cout << "姓名： " << m_Name << " 年龄：" << m_Age << endl;
	//}

	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 << "姓名： " << m_Name << " 年龄：" << m_Age << endl;
}

void test01()
{
	Person<string, int>p("Tom", 20);
	p.showPerson();
}

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

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

1.3.7 类模板分文件编写

学习目标：

掌握类模板成员函数分文件编写产生的问题以及解决方式

问题：

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

解决：

解决方式1：直接包含.cpp源文件
解决方式2：将声明和实现卸载同一个文件中，并更改后缀为.hpp，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;
}

cpp

#include<iostream>
#include<string >
using namespace std;
#include"person.hpp"

//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;
//}
// 

//2、解决方法 将.h和.cpp内容写在一起，将后缀名改为.hpp文件


void test01()
{
	Person<string, int>p("Jerry", 18);
	p.showPerson();
}
int main()
{
	test01();
	system("pause");
	return 0;
}

1.3.8 类模板与友元

学习目标：

掌握类模板配合友元函数的类内和类外实现

全局函数类内实现-直接在类内声明友元即可

全局函数类外实现-需要提前让编译器知道全局函数的存在

示例：

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

//提前让编译器知道类模板
template<class T1, class T2>
class Person;
//类外实现
template<class T1, class T2>
void printPerson2(Person<T1, T2>p)
{
	cout << "类外实现：" << "姓名:" << p.m_Name << " 年龄：" << p.m_Age << endl;
}

//通过全局函数 打印Person信息

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

	//全局函数 类外实现
	//加空参数列表
	//如果全局函数是类外实现需要让编译器提前知道这个类模板的存在
	friend void printPerson2<>(Person<T1, T2>p);

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

private:
	T1 m_Name;
	T2 m_Age;
};



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


void test02()
{
	Person<string, int>p ("Jerry", 20);
	printPerson2(p);
}

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

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

hmoban主题是根据ripro二开的主题，极致后台体验，无插件，集成会员系统
自学咖网 » 01章-模板

wen 普通

分享到：

1.1 模板的概念

1.2 函数模板

1.2.1 函数模板语法

1.2.2 函数模板注意事项

1.2.3 函数模板案例

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

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

1.2.6 模板的局限性

1.3 类模板

1.3.1 类模板语法

1.3.2 类模板与函数模板区别

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

1.3.4 类模板对象做函数参数

1.3.5 类模板与继承

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

1.3.7 类模板分文件编写

1.3.8 类模板与友元

wen 普通

相关推荐