C++语法基础(二)模板、STL、容器数据结构

模板

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

函数模板

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

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

// 数据交互函数模板
// 声明T是一个通用的数据类型
template<typename T>
void mySwap(T &a, T &b)
{
	T temp = a;
	a = b;
	b = temp;
}

void test01()
{
int a = 10;
int b = 20;
double c = 1.0;
double d = 2.0;
// 利用函数模板交换数据有两种方式
//1、自动类型推到
mySwap(a, b);
// 2、显示指定类型
mySwap<int>(a,b);
}

• 使用模板必须确定出数据类型T，且T的数据类型要保持一致

---

函数模板应用案例——字符串数组与数字数组排序

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

// 通用模板交换数字
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 min = i; // 假定当前值为最小值
		for (int j = i + 1; j < len; j++) 
		{
			if(arr[min]> arr[j])
			{
				min = j;
			}
		}
		if (min != i)
		{
			mySwap(arr[i], arr[min]);
		}
	}
}
// 通用模板打印数组
template<class T>
void printArray(T arr[], int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << arr[i] << " ";
	}
}
void test01()
{
	char charArr[] = "bdcae";
	int num = sizeof(charArr) / sizeof(char);
	mySort(charArr, num);
	printArray(charArr, num);
}
void test02()
{
	int intArr[] = {4,5,1,2,6,3,9,8,7};
	int num = sizeof(intArr) / sizeof(int);
	mySort(intArr, num);
	printArray(intArr, num);
}
int main()
{	
	test01();
	test02();
	system("pause");
	return 0;
}

---

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

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

int addNum(int a, int b)
{
	return a+b;
}
void test()
{
	int a = 10;
	int b = 20;
	char c = 'c'; // a-97 c-99
	cout << addNum(a,c) << endl;
}

cout << addNum(a,c) << endl;
会输出109，因为函数会自动将字符c转为其对应的ASCLL码99

普通函数与函数模板的同名时调用规则

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

函数模板并非万能，有些特点数据类型，需要具体化方式做特殊实现

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

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

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

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

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()
{

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

类模板

语法：

template<typename T>
类的声明或者定义

类模板与函数模板语法相似，在声明模板template后边加类就是类模板

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

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

	void showPerson()
	{
		cout << "name:" << this->m_Name << "age:" << this->m_Age << endl;
	}

	NameType m_Name;
	AgeType m_Age;
};

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

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

类模板与函数模板的区别

• 类模板没有自动类型推导使用方式，只能用<tpye>显示指定类型
• 类模板在参数列表可以有默认参数
  template<class NameType, class AgeType = int>

类模板中成员函数在调用的时候才会去创建出来

类模板对象做函数参数

• 指定传入类型
  void printPerson1(Person<string, int>& p)
• 参数模板化
  template<class T1, class T2> void printPerson2(Person<T1, T2>& p)
• 整个类模板化
  template<class T> void printPerson3(T &p)

第一种是最常用的

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

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

	void showPerson()
	{
		cout << "name:" << this->m_Name << "age:" << this->m_Age << endl;
	}

	NameType m_Name;
	AgeType m_Age;
};
//1、指定传入类型
void printPerson1(Person<string, int>& p)
{
	p.showPerson();
}
//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;
}
//3整个类模板化
template<class T>
void printPerson3(T &p)
{
	p.showPerson();
}

void test01()
{
	Person<string, int> p1("孙悟空", 999);
	printPerson1(p1);
	Person<string, int> p2("猪八戒", 789);
	printPerson2(p2);
	Person<string, int> p3("唐僧", 25);
	printPerson3(p3);
}

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

类模板与继承

当类模板碰到继承时，需要注意

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

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

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

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

可以直接告诉子类父类模板数据类型
class Son1:public Base<int>

或者将子类也变为一个模板，用T2指代父类模板中数据类型，用T1指代自身数据类型，当然T1还可以根据子类数据类型个数追加。
template<class T1, class T2> class Son2:public Base<T2>

类模板成员函数类外实现

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

// 类模板
template<class NameType, class AgeType>
class Person
{
public:
	Person(NameType name, AgeType age);

	void showPerson();

	NameType m_Name;
	AgeType 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 << "name:" << this->m_Name << "age:" << this->m_Age << endl;
}

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

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

构造函数类外实现
template <class T1, class T2> Person<T1, T2>::Person(T1 name, T2 age)
成员函数的类外实现
template <class T1, class T2> void Person<T1, T2>::showPerson()

类模板分文件编写

问题

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

解决

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

类模板与友元

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

通用数组类案例

---

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

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

// 通用数组类
#pragma once
#include <iostream>
using namespace std;

template<class T>
class MyArray
{
public:
	MyArray(int capacity) 
	{
		// cout << "MyArray的有参构造" << endl;
		this->m_Capacity = capacity;
		this->m_Size = 0;
		this->pAddress = new T[this->m_Capacity];
	}

	// 拷贝构造
	MyArray(const MyArray& arr)
	{
		// cout << "MyArray的拷贝构造" << endl;
		this->m_Capacity = arr.m_Capacity;
		this->m_Size = arr.m_Size;
		this->pAddress = new T[arr.m_Capacity];

		// 将arr中的数据都拷贝过来
		for (int i = 0; i < this->m_Size; i++)
		{
			this->pAddress[i] = arr.pAddress[i];
		}
	}

	// operator= 防止浅拷贝问题
	MyArray& operator=(const MyArray& arr)
	{
		// cout << "MyArray的=拷贝" << endl;
		// 先判断原来堆区是否有数据，如果有先释放
		if (this->pAddress != NULL)
		{
			delete[] this->pAddress;
			this->pAddress = NULL;
			this->m_Capacity = 0;
			this->m_Size = 0;
		}
		// 深拷贝
		this->m_Capacity = arr.m_Capacity;
		this->m_Size = arr.m_Size;
		this->pAddress = new T[arr.m_Capacity];
		// 将arr中的数据都拷贝过来
		for (int i = 0; i < this->m_Size; i++)
		{
			this->pAddress[i] = arr.pAddress[i];
		}
		return *this;
	}
	//尾插法
	void Push_Back(const T& val)
	{
		// 判断是否有剩余容量
		if (this->m_Capacity == this->m_Size)
		{
			return;
		}
		this->pAddress[this->m_Size] = val; //在数组尾部插入数据
		this->m_Size++; // 更新数组大小
	}

	//尾删法
	void Pop_Back(const T& val)
	{
		// 判断是否有数组为空
		if (this->m_Size == 0)
		{
			return;
		}
		this->pAddress[this->m_Size] = val; //在数组尾部插入数据
		this->m_Size--; // 更新数组大小
	}

	// 重载[] 让数组可以通过下标返回对应的数据
	T& operator[](int index)
	{
		return this->pAddress[index];
	}
	// 返回数组容量
	int getCapacity()
	{
		return this->m_Capacity;
	}
	// 返回数组大小
	int getSize()
	{
		return this->m_Size;
	}

	~MyArray()
	{
		// cout << "MyArray的析构" << endl;
		if (this->pAddress != NULL)
		{
			delete[] this->pAddress;
			this->pAddress = NULL;
		}
	}

private:
	T* pAddress; // 指针指向堆区开辟的真实数组
	int m_Capacity; // 数组容量
	int m_Size; //数组大小
};

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

void printIntArray(MyArray <int>& arr)
{
	for (int i = 0; i < arr.getSize(); i++)
	{
		cout << arr[i] << endl;
	}
}

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

	void showPerson()
	{
		cout << "name:" << this->m_Name << "age:" << this->m_Age << endl;
	}

	string m_Name;
	int m_Age;
};

void printPersonArray(MyArray <Person>& arr)
{
	for (int i = 0; i < arr.getSize(); i++)
	{
		cout << "姓名："<< arr[i].m_Name << "年龄：" << arr[i].m_Age  << endl;
	}
}

void test01()
{
	MyArray <int>arr1(5);
	for (int i = 0; i < 5; i++)
	{
		// 利用尾插法向数组中插入数据
		arr1.Push_Back(i);
	}
	cout << "arr1的打印输出为: " << endl;
	printIntArray(arr1);

	cout << "arr1的容量为：" <<arr1.getCapacity() << endl;
	cout << "arr1的大小为：" <<arr1.getSize() << endl;
}

void test02()
{
	MyArray <Person> arr1(10);

	Person p1("孙悟空", 999);
	Person p2("韩信", 20);
	Person p3("妲己", 21);
	Person p4("安其拉", 25);
	Person p5("赵云", 27);

	// 利用尾插法向数组中插入数据
	arr1.Push_Back(p1);
	arr1.Push_Back(p2);
	arr1.Push_Back(p3);
	arr1.Push_Back(p4);
	arr1.Push_Back(p5);

	cout << "arr1的打印输出为: " << endl;
	printPersonArray(arr1);

	cout << "arr1的容量为：" << arr1.getCapacity() << endl;
	cout << "arr1的大小为：" << arr1.getSize() << endl;

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

STL(Standard Template Library)标椎模板库

STL从广义上分为：容器（container）算法（algorithm）迭代器（iterator）
STL大体分为六大组件，分别是

• 容器（各种数据结构，vector、list、deque、set、map）
• 算法（各种常用算法：sort、find、copy、for_each）
• 迭代器（扮演了容器与算法之间的胶合剂）
• 仿函数（行为类似函数，可作为算法的某种策略）
• 适配器（一种用来修饰容器或者仿函数或迭代器接口的东西）
• 空间配置器（负责空间配置与管理）

vector

• vector数据结构和数组非常类似，也称为单端数组

• vector与普通数组的区别在于数组是静态空间，vector可以动态扩展，动态拓展并不是在原有空间之后接续新空间，而是找到更大的内存空间，然后将原数据拷贝新空间，释放原空间*

• vector容器的迭代器是支持随机访问的迭代器

vector构造函数

创建vector容器
vector v;
函数原型

赋值操作

vector容量和大小

resize重置vector大小，并为超出长度赋予默认值

vector插入和删除

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm> // 标准算法头文件


// vector容器存放内置数据类型

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

void printVector(vector<int> v)
{
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}
void test01()
{
	vector<int> v1;
	v1.push_back(10);
	v1.push_back(20);
	v1.push_back(30);
	v1.push_back(40);
	v1.push_back(50);

	printVector(v1);

	v1.pop_back(); // 尾删最后一个元素
	printVector(v1);

	v1.insert(v1.begin(), 100); // 插入，第一个参数是迭代器，在开头插入100

	v1.insert(v1.begin(), 2, 1000); // 在开头插入2个100

	v1.erase(v1.begin()); // 删除头元素

	v1.erase(v1.begin(), v1.end()); // 删除从头到尾，即可以删除一个区间（左闭右开）
	v1.clear(); // 上述代码等价于这一行的清空vector

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

	return 0;
}

vector数据存取

[] 与 at 的形式与string是类似的

.front() // 第一个元素
.back() // 最后一个元素

vector存储与遍历

vector存放内置数据类型
vector存放自定义数据类型
vector存放自定义数据类型 指针

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm> // 标准算法头文件

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


void myPrint(int val)
{
	cout << val << endl;
}
void test01()
{
	// 创建了一个vector容器，数组
	// vector容器存放内置数据类型
	vector<int>v;

	// 向容器尾插数据
	v.push_back(10);
	v.push_back(20);
	v.push_back(30);
	v.push_back(40);
	//通过迭代器访问容器中的数据
	//vector<int>::iterator itBegin = v.begin();//起始迭代器，指向容器中第一个元素
	//vector<int>::iterator itEnd = v.end();//结束迭代器，指向容器中最后一个元素的下一个位置

	 第一种遍历方式
	//while (itBegin != itEnd)
	//{
	//	cout << *itBegin << endl;
	//	itBegin++;
	//}

     //第二种遍历方式
	//for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	//{
	//	cout << *it << endl;
	//}
	//第三种遍历方式用STL提供的遍历算法
	for_each(v.begin(), v.end(), myPrint);


}
void test02()
{
	// 创建了一个vector容器，数组
	vector<Person>v;
	Person p1("aaa", 10);
	Person p2("bbb", 20);
	Person p3("ccc", 40);
	Person p4("ddd", 90);
	// 向容器尾插数据
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);

	//遍历容器中的数据
	for (vector<Person>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << "姓名：" << (*it).m_Name << "姓名：" << (*it).m_Age << endl;
	}

}

// 存放自定义数据类型 指针
void test03()
{
	vector<Person*>v;
	Person p1("aaa", 10);
	Person p2("bbb", 20);
	Person p3("ccc", 40);
	Person p4("ddd", 90);
	// 向容器尾插数据
	v.push_back(&p1);
	v.push_back(&p2);
	v.push_back(&p3);
	v.push_back(&p4);
	//遍历容器中的数据
	for (vector<Person*>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << "姓名：" << (*it)->m_Name << "姓名：" << (*it)->m_Age << endl;
	}
	
}
int main()
{
	test01();
	test02();
	system("pause");

	return 0;
}

vector容器嵌套容器

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm> // 标准算法头文件


// vector容器存放内置数据类型

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

void myPrint(int val)
{
	cout << val << endl;
}
void test01()
{
	// 创建了一个vector容器，数组
	//vector 存放自定义数据类型
	vector<vector<int>>v;
	// 创建小容器
	vector<int>v1;
	vector<int>v2;
	vector<int>v3;
	vector<int>v4;

	//向小容器中添加数据
	for (int i = 0; i < 4; i++)
	{
		v1.push_back(i + 1);
		v2.push_back(i + 2);
		v3.push_back(i + 3);
		v4.push_back(i + 4);
	}
	// 向大容器尾插小容器
	v.push_back(v1);
	v.push_back(v2);
	v.push_back(v3);
	v.push_back(v4);

	//遍历大容器，进而遍历所有数据
	for (vector<vector<int>>::iterator it = v.begin(); it != v.end(); it++)
	{
		for (vector<int>::iterator vit = (*it).begin(); vit != (*it).end(); vit++)
		{
			cout << (*vit) << " ";
		}
		cout << endl;
	}

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

	return 0;
}

vector容量互换

vector预留空间

减少vector在动态扩展容量时的次数

函数原型：
*reserve(int len); // 容器预留len个元素长度，预留位置不初始化，元素不可访问

string

string是C++风格的字符串，本质是一个类
string 和 char*的区别

• char* 是一个指针
• string 是一个类，类内部封装了char*, 管理这个字符串，是一个char*型的容器

特点：
string 类内部封装了很多成员方法
例如：查找find，拷贝copy，删除delete，替换replace，插入insert
string管理char*所分配的内存，不用担心复制越界和取值越界，由类内部进行负责。

string构造函数

构造函数原型：

• string(); //创建一个空的字符串，例如string str
• string(const char* s); // 使用字符串s初始化
• string(const string& str); // 使用一个string对象初始化另一个string对象
• string(int n, char c) // 使用n个字符初始化

string赋值操作

string& operator=(const char* s); // char*类型字符串，赋值给当前字符串
string& operator=(const string &s); // 字符串s赋值给当前字符串
string& operator=(char c); // 字符赋值给当前的字符串
string& assign(const char *s); // 把字符串s赋给当前的字符串
string& assign(const char *s, int n); // 把字符串s的前n个字符赋值给当前的字符串
string& assign(const string &s); //把字符串s赋值给当前的字符串
string& assign(int n, char c); // 用n个字符c赋值给当前字符串

string字符串拼接

实现字符串末尾拼接字符串

函数原型

• string& operator+=(const char* str);
• string& operator+=(const char c);
• string& operator+=(const string& str);
• string& append(const char *s);
• string& append(const char *s, int n);
• string& append(const string &s);
• string& append(const string &s, int pos, int n) // 字符串s中从pos开始的n个字符连接到字符串末尾

string查找和替换

• 查找：查找指定字符串是否存在
• 替换：指定位置替换字符串

函数原型

• int find(const string& s, str, int pos = 0) const; // 查找str第一次出现的位置，从pos开始查找
• int find(const char* s, int pos = 0) const;
• int find(const char* s, int pos, int n) const // 从pos位置查找s的前n个字符第一次位置
• int find(const char c, int pos = 0) const; // 查找字符c第一次出现位置
• int rfind(const string& str, int pos = npos) const // 查找str最后一次位置，从pos开始查找
• int rfind(const char* s, int pos = npos) const;// 查找s最后一次出现位置，从pos开始查找
• int rfind(const char* s, int pos, int n) const;//从pos开始查找s的前n个字符最后一次出现位置
• string& replace(int pos, int n, const string& str) // 替换从pos开始n个字符为字符串str

rfind和find的区别
rfind从右往左查找返回索引，find从左往右查找返回索引

字符串比较

功能描述

• 字符串之间的比较

比较方式

• 字符串比较是按字符的ASCLL码进行对比

= 返回 0
.>返回 1
< 返回-1

函数原型：

• int compare(const string &s) const; // 与字符串s比较
• int compare(const char *s) const // 与字符串s比较
  

string 存取

• 通过[]访问单子字符
• 通过at方式访问单个字符

也可进行修改：

string插入和删除

函数原型：

string子串

函数原型：
string substr(int pos = 0, int n = npos) const // 返回由pos开始的n个字符组成的字符串

使用find找到要截取的字符串尾部的下一个元素的索引pos，然后substr(0, pos)截取到。

deque

• 双端数组，可以对头端进行插入删除操作

deque与vector的区别

• vector对于头部的插入效率低，数据量越大，效率越低
• deque相对而言，对头部的插入删除速度会比vector快
• vector访问元素的速度会比deque快，这与两者的内部实现有关

deque内部工作原理

*deque容量的迭代器也是支持随机访问的

deque构造函数

deque赋值操作

deque大小操作

与vector相比，deque没有capacity()，因为它双向扩展，没有容量的概念

deque插入和删除

deque数据存取

deque排序

#include<deque>
#include<algorithm>

默认排序规则是从小到大

支持随机访问的迭代器的容器都可以利用sort算法直接对其进行排序

stack

stack基本概念
概念：stack是一种先进后出的数据结构，它只有一个出口。

stack常用接口

queue

队列，先进先出

队列只有队头和队尾可以被外界使用，队列不允许有遍历行为，队列进数据称为入队（push），出队（pop）

queue常用接口

list链表

链表的优点是可以对任意位置进行快速的插入或删除元素

缺点：
容量遍历速度没有数组快，占用空间比数组大
STL中的链表list是一个双向循环链表，next指向下一个节点，prev指向上一个节点，首尾循环相连

链表的存储方式不是连续的内存空间，链表的迭代器只支持前移和后移，属于双向迭代器

List有一个重要性质插入操作和删除操作都不会造成原有list迭代器的失效，这在vector是不成立的。

STL中list和vector是两个最常用的容器。

list构造函数

list赋值和操作

list大小操作

list插入和删除

插入的位置是迭代器
比较特别的是remove(elem)函数，删除链表中与elem相等的元素

list数据存取

list不是连续空间，不支持随机访问，不可用通过[]或者at()访问，不可用跳跃访问，只能递增递减（双向）

list反转和排序

pari

对组，成对出现的数据，利用对组可以返回两个数据。

set / multiset

• 所有元素在插入时自动排序
• set/multiset属于关联式容器，底层结构是二叉树实现的
• set和multiset的区别是set中不允许有重复元素，multiset允许容器中有重复的元素

set的构造

set在插入数据的时候只有insert的方式

set的大小和交换

set的插入和删除

set查找和统计

对于set count()的结果只能是0或者1，对于multiset结果可以大于1
find()返回的是一个迭代器

set和multiset的区别

set插入时是有返回值的，返回一个对组，对组的第一个元素是插入的迭代器位置，第二个元素是表示插入是否成功的布尔值

set 容器排序

默认情况下是升序，指定插入为降序：

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm> // 标准算法头文件
#include<set>

class MyCompare
{
public:
	bool operator()(int v1, int v2)const
	{
		return v1 > v2;
	}
};

void myPrint(int val)
{
	cout << val << endl;
}
void test01()
{
	set<int>s1;
	s1.insert(10);
	s1.insert(40);
	s1.insert(30);
	s1.insert(20);
	s1.insert(50);

	// 默认在插入时会按从小到大升序排列

	for (set<int>::iterator it = s1.begin(); it != s1.end(); it++)
	{
		cout << *it << "";
	}
	cout << endl;

	//指定排序规则为从大到小
	set<int, MyCompare> s2;

	s2.insert(10);
	s2.insert(40);
	s2.insert(30);
	s2.insert(20);
	s2.insert(50);

	for (set<int, MyCompare>::iterator it = s2.begin(); it != s2.end(); it++)
	{
		cout << *it << "";
	}
	cout << endl;

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

	return 0;
}

注：bool operator()(int v1, int v2)const排序规则定义需要为常函数（不可修改变量）
在函数定义最后加const修饰

也可以对自定义数据类型进行排序

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm> // 标准算法头文件
#include<set>
#include<string>

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

class MyCompare
{
public:
	bool operator()(const Person &p1, const Person &p2) const
	{
		// 按照年龄降序
		return p1.m_Age > p2.m_Age;
	}
};


void myPrint(int val)
{
	cout << val << endl;
}
void test01()
{
	set<Person, MyCompare> s;

	// 自定义的数据需要指定排序规则
	Person p1("刘备", 24);
	Person p2("关羽", 28);
	Person p3("张飞", 25);
	Person p4("赵云", 21);

	s.insert(p1);
	s.insert(p2);
	s.insert(p3);
	s.insert(p4);

	for (set<Person, MyCompare>::iterator it = s.begin(); it != s.end(); it++)
	{
		cout << "姓名：" << (*it).m_Name << " 年龄：" << (*it).m_Age << endl;
	}


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

	return 0;
}

注：bool operator()(const Person &p1, const Person &p2) const排序规则定义需要为常函数（不可修改变量）
在函数定义最后加const修饰

map / multimap

• map中所有的元素都是pair对组
• pair中第一个元素为key（键值）起到索引的作用，第二个元素为value（实值）
• 所有元素会根据元素的键值自动排序
• map / multimap属于关联式容器，底层结构是二叉树

优点：

• 可以根据key值快速找到value值

map和multimap的区别：

• map不允许容器中有重复键值key的元素
• multimap允许容器中有重复元素key的元素

map构造赋值

map大小和交换

map插入和删除

不建议采用[]的方式来插入数据，因为假如map中不存在对应的索引，这种方式会给所在索引位置插入值为0的元素

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm> // 标准算法头文件
#include<set>
#include<string>
#include<map>

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

class MyCompare
{
public:
	bool operator()(const Person &p1, const Person &p2) const
	{
		// 按照年龄降序
		return p1.m_Age > p2.m_Age;
	}
};


void printMap(map<int, int>& m)
{
	for (map<int, int>::iterator it = m.begin(); it != m.end(); it++)
	{
		cout << "key = " << (*it).first << "value = " << (*it).second;
	}
	cout << endl;
}

void test01()
{
	map<int, int> m;

	// 插入
	// 第一种
	m.insert(pair<int, int>(1, 10));
	// 第二种
	m.insert(make_pair(2, 20));
	// 第三种
	m.insert(map<int, int>::value_type(3, 30));
	// 第四种
	m[4] = 40;

	printMap(m);

	m.erase(m.begin()); // 按照迭代器删除
	
	m.erase(3); // 按照索引删除

	// m.erase(m.begin(), m.end()); // 按照区间删除

	m.clear(); // 清空map





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

	return 0;
}

map查找和统计

find(key) // 查找key是否存在，若存在返回该键元素的迭代器，若不存在，返回set.end()
count(key) // 统计key的元素的个数

map容器排序

利用仿函数改变排序规则

STL函数对象

概念：

• 重载函数调用操作符的类，其对象称为函数对象
• 函数对象使用重载的()时，行为类似函数调用，也叫仿函数

本质：

• 函数对象（仿函数）是一个类，不是一个函数。

谓词

概念：

• 返回bool类型的仿函数称为谓词
• 如果operator()接受一个参数，那么叫做一元谓词
• 如果operator()接受两个参数，那么叫做二元谓词

一元谓词案例：

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm> // 标准算法头文件
#include<set>
#include<string>
#include<map>
#include<vector>

class GreaterFive
{
public:
	bool operator()(int val)
	{
		return val > 5;
	}
};

void test01()
{
	vector<int>v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}
	// 查找容器中，有没有大于5的数
	vector<int>::iterator it = find_if(v.begin(), v.end(), GreaterFive());
	cout << *it << endl;
}
int main()
{
	test01();
	system("pause");

	return 0;
}

二元谓词：

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm> // 标准算法头文件
#include<set>
#include<string>
#include<map>
#include<vector>

class GreaterFive
{
public:
	bool operator()(int val)
	{
		return val > 5;
	}
};

class MyCompare
{
public:
	bool operator()(int val1, int val2)
	{
		return val1 > val2;
	}
};

void test01()
{
	vector<int>v;
	v.push_back(10);
	v.push_back(40);
	v.push_back(20);
	v.push_back(30);
	v.push_back(60);
	// 查找容器中，有没有大于5的数
	sort(v.begin(), v.end());
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;

	// 使用函数对象改变算法策略，变规则为从大到小

	sort(v.begin(), v.end(), MyCompare());

	cout << "---------" << endl;

	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}
int main()
{
	test01();
	system("pause");

	return 0;
}

内建函数对象（仿函数）

STL内建了一些函数对象
分类：

• 算术仿函数
• 关系仿函数
• 逻辑仿函数

用法：

• 这些仿函数产生的对象用法和一般函数完全相同
• 使用内建函数对象需要引入头文件#include<functional>

算术仿函数

注：两数相加必定是同种类型，因此<>中只需要一个类型声明。

关系仿函数

sort(v.begin(), v.end(), greater<int>());

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm> // 标准算法头文件
#include<set>
#include<string>
#include<map>
#include<vector>
#include<functional>

class MyCompare
{
public:
	bool operator()(int val1, int val2)
	{
		return val1 > val2;
	}
};

void test01()
{
	vector<int>v;

	v.push_back(10);
	v.push_back(20);
	v.push_back(30);
	v.push_back(40);
	v.push_back(50);

	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout <<endl;
	// 自写仿函数降序
	//sort(v.begin(), v.end(), MyCompare());

	//for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	//{
	//	cout << *it << endl;
	//}

	cout << "------------" << endl;
	// 使用STL内置仿函数
	sort(v.begin(), v.end(), greater<int>());
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}
int main()
{
	test01();
	system("pause");

	return 0;
}

逻辑仿函数

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm> // 标准算法头文件
#include<set>
#include<string>
#include<map>
#include<vector>
#include<functional>

void test01()
{
	vector<bool>v;

	v.push_back(true);
	v.push_back(false);
	v.push_back(true);
	v.push_back(false);
	v.push_back(false);

	for (vector<bool>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout <<endl;
	
	// 利用逻辑非 将容器v搬运到容器v2中，并执行取反操作

	vector<bool>v2;
	v2.resize(v.size());

	transform(v.begin(), v.end(), v2.begin(), logical_not<bool>());

	for (vector<bool>::iterator it = v2.begin(); it != v2.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}
int main()
{
	test01();
	system("pause");

	return 0;
}

STL-常用算法

概述

• 算法主要由头文件<algorithm> <functional> <numeric>组成
• <algorithm> 是所有STL头文件中最大的一个，范围涉及到比较，交换，查找，遍历操作，复制，修改等
• <functional>定义了一些模板类，用于声明函数对象（仿函数）
• <numeric>体积很小，只在几个在序列上边进行简单数学运算的模板函数

遍历算法

• for_each

遍历一个容器并提供操作接口
_func函数可以获取到迭代器指向的容器内的元素

• transform
  

查找算法

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm> // 标准算法头文件
#include<set>
#include<string>
#include<map>
#include<vector>
#include<functional>

class Person
{
public:
	Person(string name, int age)
	{
		this->m_Age = age;
		this->m_Name = name;
	}
	// 重载 == 让底层的find知道如何对比Person数据类型
	bool operator==(const Person& p)
	{
		if (this->m_Age == p.m_Age && this->m_Name == p.m_Name)
		{
			return true;
		}
		else
		{
			return false;
		}
	}

	string m_Name;
	int m_Age;
};

void test01()
{
	vector<int>v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}

	vector<int>::iterator it = find(v.begin(), v.end(), 5);

	if (it == v.end())
	{
		cout << "没有找到" << endl;
	}
	else
	{
		cout << "找到：" << *it << endl;
	}
}

void test02()
{
	vector<Person>v1;
	v1.push_back(Person("aaa", 10));
	v1.push_back(Person("bbb", 20));
	v1.push_back(Person("ccc", 30));
	v1.push_back(Person("ddd", 40));

	vector<Person>::iterator it = find(v1.begin(), v1.end(), Person("bbb", 20));
	if (it == v1.end())
	{
		cout << "没有找到" << endl;
	}
	else
	{
		cout << "找到元素 姓名：" << it->m_Name << "年龄：" << it->m_Age << endl;
	}
}
int main()
{
	test01();
	test02();
	system("pause");

	return 0;
}

排序算法

拷贝和替换算法

算术生成算法

常用集合算法