蘭くどうしんいち

黑马程序员C++笔记——STL泛型编程VS2019

1 函数模板

1.1 函数模板基本语法

1.2 函数模板注意事项

1.3 函数模板案例—数组排序

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

1.5 普通函数与函数模板调用规则

1.6 模板的局限性

2 类模板

2.1 类模板语法

2.2 类模板和函数模板的区别

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

2.4 类模板对象做函数参数

2.5 类模板与继承

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

2.7 类模板分文件编写

2.8 类模板与友元

2.9 类模板案例—数组类封装

3 STL初识

3.1 STL的基本概念

3.2 vector存放内置数据类型

3.3 vector存放自定义数据类型

3.4 容器嵌套容器

4 string容器

4.1 构造函数

4.2 赋值操作

4.3 字符串拼接

4.4 字符串查找和拼接

4.5 字符串比较

4.6 字符存取

4.7 字符串的插入和删除

4.8 子串获取

5 vector容器

5.1 构造函数

5.2 赋值操作

5.3 容量和大小

5.4 插入和删除

5.5 数据存取

5.6 互换容器

5.7 预留空间

6 deque容器

6.1 构造函数

6.2 赋值操作

6.3 大小操作

6.4 插入和删除

6.5 数据存取

6.6 排序操作

6.7 案例-评委打分

7 stack容器

8 queue 容器

9 list容器

9.1 基本概念

9.2 构造函数

9.3 赋值和交换

9.4 大小操作

9.5 插入和删除

9.6 数据存取

9.7 反转和排序

9.8 list容器排序案例

10 set/multiset容器

10.1 构造和赋值

10.2 大小和交换

10.3 插入和删除

10.4 查找和统计

10.5 set和multiset区别

10.6 pair对组创建使用

10.7 内置类型指定排序规则

10.8 自定义数据类型指定排序规则

11 map/multimap容器

11.1 构造和赋值

11.2 大小和交换

11.3 插入和删除

11.4 查找和统计

11.5 排序

12 STL案例—员工分工

13 函数对象—函数对象基本使用

14 谓词

14.1 一元谓词

14.2 二元谓词

15 内建函数对象

15.1 算术仿函数

15.2 关系仿函数

15.3 逻辑仿函数

16 常用遍历算法

16.1 for_each

16.2 transform

17 常用查找算法

17.1 find

17.2 find_if

17.3 adjacent_find

17.4 binary_search

17.5 count

17.6 count_if

18 常用排序算法

18.1 sort

18.2 random_shuffle

18.3 merge

18.4 reverse

19 常用拷贝和替换算法

19.1 copy

19.2 replace

19.3 replace_if

19.4 swap

20 常用算术生成算法

20.1 accumulate

20.2 fill

21 常用集合算法

21.1 set_intersection

21.2 set_union

21.3 set_difference

22 演讲比赛流程管理系统

23 机房预约系统

24 综合：搭配之前学的Qt做的通讯管理系统

1 函数模板

1.1 函数模板基本语法

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

2、语法：

template//声明一个模板，T是一个通用的数据类型

函数声明或定义

#include 
using namespace std;
template//声明一个模板，T是一个通用的数据类型
void mySwap(T &a, T &b)//
{
	T temp = a;
	a = b;
	b = temp;
}
int main()
{
	int a = 10;
	int b = 20;
	// 自动类型推导：必须要推导出一致的数据类型 T，模板必须要确定出T的数据类型
	mySwap(a, b);
	// 显示指定类型
	mySwap(a,b);
	cout << a << b << endl;

}

1.2 函数模板注意事项

1、自动类型推导，必须推导出一致的数据类型T，才可以使用；

2、模板必须要确定出T的数据类型，才可以使用。

#include 
using namespace std;
template//typename可以替换成class
void mySwap(T &a, T &b)//
{
	T temp = a;
	a = b;
	b = temp;
}
void test01()
{
	int a = 0;
	int b = 0;
	char c = 'c';
	mySwap(a, b);
	//mySwap(a, c);错误,推导不出一致的T类型
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
}
template
void func()
{
	cout << "func 调用" << endl;
}
void test02()
{
	//func(); 错误，没有指定出T
	func();
}
int main()
{	
	test01();
	test02();
}

1.3 函数模板案例—数组排序

1、实现一个通用对数组进行排序的函数
2、规则从大到小
3、算法冒泡
4、测试数组 char数组 int数组

#include 
using namespace std;
//实现一个通用 对数组进行排序的函数
//规则 从大到小
//算法 冒泡
//测试数组 char数组 int数组
template
void printArray(T arr[], int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
}
/*template*///typename可以替换成class
//void mySwap(T& a, T& b)//
//{
//	T temp = a;
//	a = b;
//	b = temp;
//}不知道为什么，这里用这个交换没有办法排序
template
void mySort(T arr[],int len)
{
	for (int i = 0; i < len-1; i++)
	{
		for (int j = 0; j < len - i - 1; j++)
		{
			if (arr[j] < arr[j+1])
			{
				/*mySwap(arr[j], arr[i]);*/
				T temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;

			}
		}
	}
}
void test01()
{
	char charArr[] = "abcdef";
	int num = sizeof(charArr) / sizeof(char);
	mySort(charArr, num);
	printArray(charArr, num);
}
void test02()
{
	int intArray[] = { 0,3,4,6,2,8,9 };
	int num = sizeof(intArray) / sizeof(int);
	mySort(intArray, num);
	printArray(intArray, num);
}
int main()
{
	test01();
	test02();
	return 0;
}

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

1、普通函数调用可以发生隐式类型转换；

2、函数模板用自动类型推导，不可以发生隐式类型转换

3、函数模板用显示指定类型，可以发生隐式类型转换

#include
using namespace std;

int myAdd01(int a, int b)
{
	return a + b;
}
void test01()
{
	int a = 10;
	int b = 20;
	char c = 'c';
	cout << myAdd01(a, b) << endl;
	cout << myAdd01(a, c) << endl;//普通函数可以隐式转换
}
template
T myAdd02(T a, T b)
{
	return a + b;
}
void test02()
{
	int a = 10;
	int b = 20;
	char c = 'c';
	cout << myAdd02(a, c) << endl;//
	//cout << myAdd02(a, c) << endl;//函数模板 用自动类型推导，不可以发生隐式类型转换
}
int main()
{
	test01();
	test02();
	return 0;
}

1.5 普通函数与函数模板调用规则

1、如果函数模板和普通函数都可以实现，优先调用普通函数

2、可以提高空模板参数列表来强制调用函数模板

3、函数模板也可以发生重载

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

#include
using namespace std;

void myPrint(int a, int b)//只有声明还是调用普通函数，而且报错
{
	cout << "调用普通函数" << endl;
}
template
void myPrint(T a, T b)
{
	cout << "调用函数模板" << endl;
}
template
void myPrint(T a, T b,T c)//重载的模板
{
	cout << "调用重载函数模板" << endl;
}
void test01()
{
	int a = 10, b = 20;
	//myPrint(a,b);// 优先调用普通函数
	
	// 通过空模板参数列表，强制调用函数模板
	myPrint<>(a, b);
	myPrint(a, b, 100);

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

1.6 模板的局限性

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

利用具体化的模板，可以解决自定义类型的通用化

学习模板不是为了写模板，而是在STL能够运用系统提供的模板

#include
using namespace std;
#include
class Person
{
public:
	int m_age;
	string m_name;
	Person(string name, int age)
	{
		this->m_name = name;
		this->m_age = age;
	}
};
template
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_name == p2.m_name && p1.m_age == p2.m_age)
	{
		return true;
	}
	else
	{
		return false;
	}
}
void test01()
{
	int a = 10;
	int b = 10;
	bool ret = myCompare(a, b);
	if (ret == true)
	{
		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 == true)
	{
		cout << "p1=p2" << endl;
	}
	else
	{
		cout << "p1!=p2" << endl;
	}
}
int main()
{
	//test01();
	test02();
	return 0;
}

2 类模板

2.1 类模板语法

template

类

#include 
using namespace std;

template
class Person
{
public:
	NameType m_name;
	AgeType m_age;
	Person(NameType name, AgeType age)
	{
		this->m_name = name;
		this->m_age = age;
	}
	void showPerson()
	{
		cout << "name = " << this->m_name << endl;
		cout << "age = " << this->m_age << endl;
	}
};
void test01()
{
	Person p1("Tom", 10);
	p1.showPerson();
}
int main()
{
	test01();
	return 0;
}

2.2 类模板和函数模板的区别

1、类模板没有自动类型推导使用方式

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

#include 
using namespace std;
template//告诉了默认是int，后面可以不写int
class Person
{
public:
	NameType m_name;
	AgeType m_age;
	Person(NameType name, AgeType age)
	{
		this->m_name = name;
		this->m_age = age;
	}
	void showPerson()
	{
		cout << "name = " << this->m_name << endl;
		cout << "age = " << this->m_age << endl;
	}
};
void test01()
{
	//Person p("Tom", 10);//错误，无法用自动类型推导
	Person p("Tom", 10);//正确

}
void test02()
{
	Person p("Tom", 10);
}
int main()
{
	test01();
	test02();
	return 0;
}

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

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

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

#include 
using namespace std;

class Person1
{
public:
	void showPerson2()
	{
		cout << "Person1 show" << endl;
	}
};
class Person2
{
public:
	void showPerson2()
	{
		cout << "Person2 show" << endl;
	}
};
template
class Myclass
{
public:
	T obj;
	//类模板中的成员函数
	void func1()
	{
		obj.showPerson1;//没有报错
	}
	void func2()
	{
		obj.showPerson2;
	}
};
void test01()
{
	Myclassm;
	m.func1();
	//m.func2();调用的时候创建类模板成员函数
}
int main()
{
	test01();
	return 0;
}

2.4 类模板对象做函数参数

类模板实例化出的对象作为函数参数怎么传

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

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

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

#include
using namespace std;

template
class Person
{
public:
	T1 m_name;
	T2 m_age;
	Person(T1 name, T2 age)
	{
		this->m_name = name;
		this->m_age = age;
	}
	void showPerson()
	{
		cout << "name = " << this->m_name << endl;
		cout << "age = " << this->m_age << endl;
	}
};

// 1、指定传入类型——直接显示对象的数据类型
void printPerson1(Person&p)
{
	p.showPerson();
}
void test01()
{
	Personp("孙悟空", 100);
	printPerson1(p);
}

//2、参数模板化——将整个对象中的参数变为模板进行传递

template
void printPerson2(Person& p)
{
	p.showPerson();
	cout << "T1的类型为： " << typeid(T1).name() << endl;
	cout << "T2的类型为： " << typeid(T2).name() << endl;
}

void test02()
{
	Personp("猪八戒", 90);
	printPerson2(p);
}
//3、将整个类模板化
template
void printPerson3(T &p)
{
	p.showPerson();
	cout << "T的类型为： " << typeid(T).name() << endl;
}

void test03()
{
	Personp("唐僧", 30);
	printPerson3(p);
}
int main()
{
	test03();
	return 0;
}

2.5 类模板与继承

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

1、当子类继承父类是一个类模板时，子类在声明的时候，要指定出父类中的T的类型

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

3、如果想灵活指定出父类中的T类型，子类也需变为类模板

#include
using namespace std;

template
class Base
{
	T m;
};
//class Son :public Base//错误，必须要知道父类中的T类型，才能继承给子类
class Son1 :public Base
{

};
void test01()
{
	Son1 s1;
}
//如果想灵活指定出父类中的T类型，子类也需变为类模板
template 
class Son2 :public Base
{
public:
	Son2()
	{
		cout << "T1的类型为： " << typeid(T1).name() << endl;
		cout << "T2的类型为： " << typeid(T2).name() << endl;
	}
	T1 obj;
};
void test02()
{
	Son2s2;//父类是int ，子类是char
}
int main()
{
	test02();
	return 0;
}

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

#include
using namespace std;

template
class Person
{
public:
	T1 m_name;
	T2 m_age;
	Person(T1 name, T2 age);
	void showPerson();
};
//构造函数类外实现
template
Person::Person(T1 name, T2 age)
{
	this->m_age = age;
	this->m_name = name;
}
//成员函数的类外实现
template
void Person::showPerson()
{
	cout << "姓名: " << this->m_name << "年龄： " << m_age << endl;
}
void test01()
{
	Personp("Tom", 20);
	p.showPerson();
}
int main()
{
	test01();
}

2.7 类模板分文件编写

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

解决：

1、直接包含.cpp源文件

2、将声明和实习写到同一个文件中，并更改后缀名为.hpp，hpp是约定的名称，不是强制的

#include 
using namespace std;
//1、直接包含源文件
//#include "person.cpp"
// 
//2、将.h和.cpp中的内容写到一起，将后缀名改为.hpp文件
#include "person.hpp"

void test01()
{
	Personp("Jerry", 18);
	p.showPerson();
}
int main()
{
	test01();
	return 0;
}

2.8 类模板与友元

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

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

2、全局函数类外实现—需要提前让编译器自动全局函数的存在

#include
using namespace std;

//提前让编译器知道Person类存在
template
class Person;
template
void printPerson2(Personp)//类外实现
{
	cout << "姓名: " << p.m_name << " 年龄： " << p.m_age << endl;
}
//通过全局函数打印Person信息

template
class Person
{
	//全局函数 类内实现
	friend void printPerson(Personp)
	{
		cout << "姓名: " << p.m_name << " 年龄： " << p.m_age << endl;
	}
	//全局函数 类外实现,加空模版参数列表
	//如果全局函数是类外实现，需要让编译器提前知道这个函数的存在
	friend void printPerson2<>(Personp);
private:
	T1 m_name;
	T2 m_age;
public:
	Person(T1 name, T2 age)
	{
		this->m_age = age;
		this->m_name = name;
	}
};

void test01()
{
	Personp("John", 10);
	printPerson(p);
	printPerson2(p);
}

int main()
{
	test01();
	return 0;
}