C++提高编程篇

最新推荐文章于 2023-07-26 18:00:36 发布

yangyang_z

最新推荐文章于 2023-07-26 18:00:36 发布

阅读量307

点赞数

分类专栏： C++ 文章标签： c++

C++ 专栏收录该内容

24 篇文章 2 订阅

订阅专栏

C++提高编程

167_01模板-模板的概念

本阶段主要针对C++泛型编程和STL技术做详细讲解，探讨C++更深层的使用
模板就是建立通用的模具，大大提高复用性

模板的特点：

模板不可以直接使用，它只是一个框架
模板的通用并不是万能的

168_02模板-函数模板基本语法

函数模板

C++另一种编程思想称为泛型编程，主要利用的技术就是模板
C++提供两种模板机制：函数模板和类模板
函数模板作用：
建立一个通用的函数，其函数返回值类型和形参类型可以不具体指定，用一个虚拟的类型来代表。
语法：

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

解释：
template — 声明创建模板
typename —表明其后面的符号是一种数据类型，可以用class代替
T —通用的数据类型，名称可以替换，通常为大写字母

#include<iostream>
#include<string>
using namespace std;
//函数模板
//声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用数据类型
template<typename T>
void myswap(T &a, T &b){
	T temp = a;
	a = b;
	b = temp;
}
static void test(){
	int a = 10, b = 20;
	//利用函数模板交换
	//两种方式使用函数模板
	//1、自动类型推导
	//myswap(a, b);
	//2、显示指定类型
	//myswap<double>(d, e);
	myswap(a, b);
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	double d = 10.1, e = 20.3;
	myswap<double>(d, e);
	cout << "d = " << d<< endl;
	cout << "e = " << e<< endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

总结：

函数模板利用关键字template
使用函数模板有两种方式：自动类型推导，显示指定类型
模板的目的是为了提高复用性，将类型参数化

169_03模板-函数模板注意事项

注意事项：

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

#include<iostream>
#include<string>
using namespace std;
//函数模板注意事项
template<typename T>
static void myswap(T&a, T&b){
	T temp = a;
	a = b;
	b = temp;
}
//1、自动类型推导，必须推导出一致的数据类型T才可以使用
static void test(){
	int a = 10, b = 20;
	char c = 'c';
	myswap(a, b);
	//myswap(a, c);   //错误！！！

	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
}
//2、模板必须要确定出T的数据类型，才可以使用
template<typename T>
static void func(){
	cout << "func调用" << endl;
}
static void test01(){
	//func();  
	func<int>();
}
int main()
{
	test01();
	system("pause");
	return 0;
}

170_04模板-函数模板案例-数组排序

案例描述：

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

#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
//实现通用对数组进行排序的函数
//规则  从小到大
//算法  选择
//测试  char  int
//打印数组的模板
template<typename T>
static void printArray(T *arr, int len){
	for (int i = 0; i < len; i++){
		cout << *arr++ << " ";
	}
	cout << endl;
}
//排序的算法
template<typename T>
static 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[j]<arr[max]){
				max = j;    //更新最大值下标
			}
		}
		if (max != i){
			swap(arr[i], arr[max]);
		}
	}
}
static void test(){
	char charArr[] = "bacdef";
	int len = sizeof(charArr) / sizeof(charArr[0]);
	mySort(charArr, len);
	printArray(charArr, len);
}
static void test01(){
	int intArr[] = { 2, 1, 5, 7, 0, 3, 4, 6, 8, 9 };
	int len = sizeof(intArr) / sizeof(intArr[0]);
	mySort(intArr, len);
	printArray(intArr, len);
}
int main()
{
	test01();
	system("pause");
	return 0;
}

171_05模板-普通函数与函数模板区别

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

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

#include<iostream>
#include<string>
using namespace std;
//普通函数与函数模板的区别
//1、普通函数调用可以发生隐式类型转换
//2、函数模板  用自动类型推导，不可以发生隐式类型转换
//3、函数模板  用显示指定类型，可以发生隐式类型转换

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

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

static void test(){
	int a = 10, b = 20;
	char c = 'c';
	cout << myAdd01(a, c) << endl;
	//自动类型推导   ,不会发生隐式类型转换
	cout << myAdd02(a, b) << endl;
	//显示指定类型
	cout << myAdd02<int>(a, c) << endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

172_06模板-普通函数与函数模板的调用规则

调用规则如下：

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

#include<iostream>
#include<string>
using namespace std;
//普通函数与函数模板
//1、如果函数模板和普通函数都可以调用，优先调用普通函数
//2、可以通过空模板参数列表，强制调用 函数模板
//3、函数模板可以发生函数重载
//4、如果函数模板可以产生更好的匹配，优先调用函数模板

static void myPrint(int a, int b){
	cout << "调用的普通函数" << endl;
}
template<typename T>
static void myPrint(T a, T b){
	cout << "调用的模板" << endl;
}

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

static void test01(){
	int a = 10, b = 20,c = 30;
	myPrint(a, b);
	//通过空模板参数列表，强制调用 函数模板
	myPrint<>(a, b);
	myPrint(a, b, c);
	//如果函数模板产生更好的匹配，优先选择模板
	char d = 'c', f = 'e';
	myPrint(d, f);
}
int main()
{
	test01();
	system("pause");
	return 0;
}

173_07模板-模板的局限性

局限性：

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

#include<iostream>
#include<string>
using namespace std;
//模板的局限性
//模板并不是万能的，有些特定数据类型，需要用具体化方式做特殊实现
class Person{
public:
	Person(string name, int age) :m_name(name), m_age(age){

	}
	string m_name;
	int m_age;
private:
};

//对比两个数据是否相等
template<typename 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.m_name == b.m_name && a.m_age == b.m_age){
		return true;
	}
	else{
		return false;
	}
}
static void test(){
	int a = 10, b = 20;
	bool ret = myCompare(a, b);
	if (ret){
		cout << "a == b" << endl;
	}
	else{
		cout << "a!=b" << endl;
	}
}
static void test01(){
	Person p1("Tom", 10);
	Person p2("Tom", 20);
	bool ret = myCompare(p1, p2);
	if (ret){
		cout << "p1 == p2" << endl;
	}
	else{
		cout << "p1!= p2" << endl;
	}
}
int main()
{
	test01();
	system("pause");
	return 0;
}

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

174_08模板-类模板基本语法

类模板作用：
建立一个通用类，类中的成员数据类型可以不具体指定，用一个虚拟的类型来代表。
语法：
template< typename T>
类

#include<iostream>
#include<string>
using namespace std;
//类模板
template<class NameType,class AgeType> 
class Person{
public:
	Person(NameType name, AgeType age) :m_name(name), m_age(age){

	}
	NameType m_name;
	AgeType m_age;
	void showPerson(){
		cout << "name: " << this->m_name << "age: " << this->m_age << endl;
	}
};
static void test(){
	Person<string, int>p1("孙悟空", 999);
	p1.showPerson();
}
int main()
{
	test(); 
	system("pause");
	return 0;
}

175_09模板-类模板与函数模板区别

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

#include<iostream>
#include<string>
using namespace std;
//类模板与函数模板区别
template<class NameType,class AgeType = int>
class Person{
public:
	Person(NameType name, AgeType age) :m_Name(name), m_Age(age){

	}
	void showPerson(){
		cout << "name: " << this->m_Name << "age = " << this->m_Age << endl;
	}
	NameType m_Name;
	AgeType m_Age;
};
//1、类模板没有自动类型推导的使用方式
static void test(){
	//Person p("孙悟空", 1000);    //错误，无法用自动类型推导
	Person<string, int>p("孙悟空", 1000);
	p.showPerson();
}
//2、类模板在模板参数列表中可以有默认参数
static void test01(){
	Person<string>p("猪八戒", 1500);
	p.showPerson();
}
int main()
{
	test01();
	system("pause");
	return 0;
}

总结：类模板使用只能用显示指定类型方式
类模板中的模板参数列表可以有默认参数

176_10模板-类模板中成员函数创建时机

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

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

#include<iostream>
#include<string>
using namespace std;
//类模板中成员函数创建时机
//类模板中成员含还是在调用时才去创建

class Person1{
public:
	void showPerson1(){
		cout << "Person1 show" << endl;
	}
};
class Person2{
public:
	void showPerson2(){
		cout << "Person2 show" << endl;
	}
};
template<class T>
class MyClass{
public:
	T obj;
	//类模板中的成员函数 
	void func1(){
		obj.showPerson1();
	}
	void func2(){
		obj.showPerson2();
	}
};

static void test(){
	MyClass<Person1>m;
	m.func1();
	//m.func2();
}
int main()
{
	test();
	system("pause");
	return 0;
}

177_11模板-类模板对象做函数参数

类模板实例化出的对象，向函数传参的方式
一共有三种传入方式：
1、指定传入的类型：直接显示对象的数据类型
2、参数模板化：将对象中参数变为模板进行传递
3、整个类模板化：将这个对象类型模板化进行传递

#include<iostream>
#include<string>
using namespace std;
//类模板对象做函数参数
template<class T1,class T2>
class Person{
public:
	Person(T1 name, T2 age) :m_Name(name), m_Age(age){

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

//1、指定传入类型
static void printPerson1(Person<string, int>&p){
	p.showPerson();
}
static void test01(){
	Person<string, int>p("孙悟空", 100);
	printPerson1(p);
}
//2、参数模板化
template<class T1,class T2>
static void printPerson2(Person<T1, T2>&p){
	p.showPerson();
	cout << "T1的类型为：" << typeid(T1).name() << endl;
	cout << "T2的类型为：" << typeid(T2).name() << endl;
}
static void test02(){
	Person<string, int>p("猪八戒", 600);
	printPerson2(p);
}
//3、整个类模板化
template<class T>
static void printPerson3(T &p){
	p.showPerson();
	cout << "T的数据类型为：" << typeid(T).name() << endl;
}
static void test03(){
	Person<string, int>p("杨戬", 300);
	printPerson3(p);
}
int main()
{
	test03();
	system("pause");
	return 0;
}

178_12模板-类模板与继承

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

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

#include<iostream>
#include<string>
using namespace std;
//类模板与继承
template<class T>
class Base{
	T m;
};
//class Son : public Base//错误，必须要知道父类中的T类型，才能继承给子类
class Son :public Base<int>{
public:

};
static void test01(){
	Son s1;
}

//如果想灵活指定父类中T类型，子类也需要变类模板
template<class T1,class T2>
class Son2 :public Base<T2>{
public:
	Son2(){
		cout << "T1的类型为： " << typeid(T1).name() << endl;
		cout << "T1的类型为： " << typeid(T2).name() << endl;
	}
	T1 obj;
};

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

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

总结：如果父类是类模板，子类需要指定出父类中T的数据类型

179_13类模板成员函数类外实现

#include<iostream>
#include<string>
using namespace std;
//类模板成员函数类外实现
template<class T1,class T2>
class Person{
public:
	Person(T1 name, T2 age); /*:m_Name(name), m_Age(age){

	}*/

	void showPerson();/*{
		cout << "姓名： " << m_Name << "\t年龄：" << m_Age << endl;
	}*/
	T1 m_Name;
	T2 m_Age;
};

//构造函数的类外实现
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age) :m_Name(name), m_Age(age){

}
//成员函数的类外实现
template<class T1, class T2>
void Person<T1, T2>::showPerson(){
	cout << "姓名： " << m_Name << "\t年龄：" << m_Age << endl;
}
static void test(){
	Person<string, int> p("杨戬", 300);
	p.showPerson();
}
int main()
{
	test();
	system("pause");
	return 0;
}

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

180_14模板-类模板的分文件编写

掌握类模板成员函数分文件编写产生的问题以及解决方式
问题：
类模板中成员函数创建时机是在调用阶段，导致分文件编写时连接不到
解决：
解决方式1：直接包含.cpp源文件
解决方式2：将声明和实现写在同一个文件中，并更改后缀名为.hpp,hpp是约定的名称，并不是强制的。
person.hpp

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

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) :m_Name(name), m_Age(age){

}

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

#include<iostream>
//第一种解决方式，直接包含源文件
#include"180person.hpp"
//第二种解决方式，将.h和.cpp中的内容写到一起，将后缀名改为.hpp文件
using namespace std;
//类模板的分文件编写以及解决
static void test(){
	Person<string, int>p("杨戬", 300);
	p.showPerson();
}

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

181_15模板-类模板与友元

学习目标：

掌握类模板配合友元函数的类内和类外实现
全局函数类内实现-直接在类内声明友元即可
全局函数类外实现-需要提前让编译器知道全局函数的存在

#include<iostream>
#include<string>
using namespace std;
//通过全局函数 打印Person的信息
template<class T1,class T2>
class Person;
//2、类外的实现
template<class T1, class T2>
void printPerson2(Person<T1, T2> p){
	cout << "类外的实现姓名： " << p.m_Name << "\t类外的实现年龄：" << p.m_Age << endl;
}
template<class T1,class T2>
class Person{
	//全局函数 类内实现
	friend void printPerson(Person<T1,T2> p){
		cout << "姓名： " << p.m_Name << "\t年龄：" << p.m_Age << endl;
	}
	//全局函数 类外实现
	//加空模板的参数列表
	//如果全局函数  是类外实现，需要让编译器提前知道这个函数的存在
	friend void printPerson2<>(Person<T1, T2> p);/*{
		cout << "姓名： " << p.m_Name << "\t年龄：" << p.m_Age << endl;
	}*/
public:
	Person(T1 name, T2 age) :m_Name(name), m_Age(age){

	}
private:
	T1 m_Name;
	T2 m_Age;
};
//1、全局函数在类内实现
static void test(){
	Person<string, int> p("杨戬", 300);
	printPerson(p);
}


static void test02(){
	Person<string, int>p("杨戬", 300);
	printPerson2(p);
}
int main()
{
	test02();
	system("pause");
	return 0;
}

182_16模板-类模板案例-数组封装的需求分析

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

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

在这里插入图片描述

183_17模板-类模板案例-数组类封装上

183MyArray.hpp

//自己通用的数组类
#pragma once
#include<iostream>
using namespace std;
template<class T>
class MyArray{
public:
	//有参构造
	MyArray(int capacity) :m_Capacity(capacity),m_Size(0),pAddress(new T[m_Capacity]){
		cout << "MyArray的有参构造调用  " << endl;
	}
	//拷贝构造
	MyArray(const MyArray&arr){
		cout << "MyArray的拷贝构造调用  " << endl;
		this->m_Capacity = arr.m_Capacity;
		this->m_Size = arr.m_Size;
		//pAddress = arr.pAddress;
		//深拷贝
		this->pAddress = new T[arr.m_Capacity];
		//将arr中的数据都拷贝过来
		for (int i = 0; i < m_Size; i++){
			this->pAddress[i] = arr.pAddress[i];
		}
	}
	//operator=  防止浅拷贝问题
	MyArray &operator=(const MyArray&arr){
		//先判断原来堆区是否有数据，如果有先释放
		cout << "MyArray的operator= 调用  " << endl;
		if (pAddress != nullptr){
			delete[] pAddress;
			pAddress = nullptr;
			m_Capacity = 0;
			m_Size = 0;
		}
		//深拷贝
		this->m_Capacity = arr.m_Capacity;
		this->m_Size = arr.m_Size;
		this->pAddress = new T[arr.m_Capacity];
		for (int i = 0; i < m_Size; i++){
			this->pAddress[i] = arr.pAddress[i];
		}
		return *this;
	}
	//析构函数
	~MyArray(){
		cout << "MyArray的析构函数调用  " << endl;
		if (pAddress != nullptr){
			delete[] pAddress;
			pAddress = nullptr;
		}
	}
private:
	T *pAddress;      //指针指向堆区开辟的真实的数据
	int m_Capacity;   //数组的容量
	int m_Size;       //数组的大小
};

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

static void test01(){
	MyArray<int> arr(5);
	MyArray<int> arr2(arr);
	MyArray<int> arr3(100);
	arr3 = arr;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

184_18模板-类模板案例-数组封装下

//自己通用的数组类
#pragma once
#include<iostream>
using namespace std;
template<class T>
class MyArray{
public:
	//有参构造
	MyArray(int capacity) :m_Capacity(capacity),m_Size(0),pAddress(new T[this->m_Capacity]){
		//cout << "MyArray的有参构造调用  " << endl;
	}
	//拷贝构造
	MyArray(const MyArray&arr){
		//cout << "MyArray的拷贝构造调用  " << endl;
		this->m_Capacity = arr.m_Capacity;
		this->m_Size = arr.m_Size;
		//pAddress = arr.pAddress;
		//深拷贝
		this->pAddress = new T[arr.m_Capacity];
		//将arr中的数据都拷贝过来
		for (int i = 0; i < m_Size; i++){
			this->pAddress[i] = arr.pAddress[i];
		}
	}
	//operator=  防止浅拷贝问题
	MyArray &operator=(const MyArray&arr){
		//先判断原来堆区是否有数据，如果有先释放
		//cout << "MyArray的operator= 调用  " << endl;
		if (pAddress != nullptr){
			delete[] pAddress;
			pAddress = nullptr;
			m_Capacity = 0;
			m_Size = 0;
		}
		//深拷贝
		this->m_Capacity = arr.m_Capacity;
		this->m_Size = arr.m_Size;
		this->pAddress = new T[arr.m_Capacity];
		for (int i = 0; i < m_Size; i++){
			this->pAddress[i] = arr.pAddress[i];
		}
		return *this;
	}

	//尾插法
	void Push_Back(const T&val){
		//判断容量是否等于大小
		if (m_Capacity == this->m_Size){
			return;
		}
		this->pAddress[this->m_Size] = val;   //在数组末尾插入数据
		this->m_Size++;                 //更新数组大小
	}
	//尾删法
	void Pop_Back(){
		//让用户访问不到最后一个元素，即尾删，逻辑删除
		if (this->m_Size == 0){
			return;
		}
		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 != nullptr){
			delete[] this->pAddress;
			this->pAddress = nullptr;
		}
	}
private:
	T *pAddress;      //指针指向堆区开辟的真实的数据
	int m_Capacity;   //数组的容量
	int m_Size;       //数组的大小
};

185_19 STL初始-STL的基本概念

STL的诞生

长久以来，软件界一直希望建立一种可以重复利用的东西
C++的面向对象和泛型编程思想，目的就是复用性的提升
大多数情况下，数据结构和算法都未能有一套标准，导致被迫从事大量重复工作
为了建立数据结构和算法的一套标准，诞生了STL
STL基本概念
STL(Standard Template Library，标准模板库)
STL从广义上分为：容器(container)、算法（algorithm）、迭代器(iterator)
容器和算法之间通过迭代器进行无缝连接
STL几乎所有的代码都采用了模板类或者模板函数
STL六大组件
容器、算法、迭代器、仿函数、适配器（配接器）、空间配置器
1、容器：各种数据结构，如vector、list、deque、set、map等，用来存放数据。
2、算法：各种常用的算法，如sort、find、copy、for_each等
3、迭代器：扮演了容器与算法之间的胶合剂
4、仿函数：行为类似函数，可作为算法的某种策略
5、适配器：一种用来修饰容器或者仿函数或迭代器接口的东西
6、空间配置器：负责空间配置与管理
STL中容器、算法、迭代器
容器：置物之所也
STL容器就是将运用最广泛的一些数据结构实现出来
常用的数据结构：数组、链表、树、栈、队列、集合、映射、表等
这些容器分为序列式容器和关联式容器两种：
序列式容器：强调值的排序，序列式容器中的每个元素均有固定的位置
关联式容器: 二叉树结构，各元素之间没有严格的物理上的顺序关系
算法：问题之解也
有限的步骤，解决逻辑或数学上的问题，这一门学科我们叫做算法
算法分为质变算法和非质变算法
质变算法：是指运算过程中会更改区间内的元素的内容。例如拷贝、替换、删除等等。
非质变算法：是指运算过程中不会更改区间内的元素内容，例如查找、计数、遍历、寻找极值等等。
迭代器：容器和算法之间粘合剂
提供一种方法，使之能够依序寻访某各容器所含的各个元素，而又无需暴漏该容器内部表示方法。
每个容器都有自己专属的迭代器
迭代器使用非常类似于指针，初学阶段我们理解迭代器为指针

常用的容器中迭代器种类为双向迭代器，和随机访问迭代器

186_20 STL初始-vector存放内置数据类型

vector存放内置数据类型
容器：vector
算法：for_each
迭代器：vector::iterator

#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;
//vector存放的内置数组类型
static void myPrint(int val){
	cout << val << endl;
}
static void test(){
	//创建了一个vector容器，数组
	vector<int>v;
	//向容器中插入数据
	v.push_back(10);
	v.push_back(20);
	v.push_back(30);
	v.push_back(40);
	v.push_back(50);
	//通过迭代器访问容器中的数据
	vector<int>::iterator itBegin = v.begin();  //起始迭代器，指向容器中第一个元素
	vector<int>::iterator itEnd = v.end();      //结束迭代器，指向容器中最后一个元素的下一个元素
	//第一种遍历方式
	while (itBegin != itEnd){
		cout << *itBegin++ << endl;
	}
	//第二种遍历方式
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++){
		cout << *it << endl;
	}
	//第三种遍历算法 利用STL中提供的遍历算法
	for_each(v.begin(), v.end(), myPrint);
}
int main()
{
	test();
	system("pause");
	return 0;
}

187_21STL初识-vector存放自定义数据类型

#include<iostream>
#include<string>
#include<vector>
using namespace std;
//vector容器中存放自定义数据类型
class Person{
public:
	Person(string name, int age) :m_Name(name), m_Age(age){

	}
	string m_Name;
	int m_Age;
};
static void test(){
	vector<Person> v;
	Person p1("aaa", 10);
	Person p2("bbb", 20);
	Person p3("ccc", 30);
	Person p4("ddd", 40);
	Person p5("eee", 50);
	Person p6("fff", 60);
	//向容器中添加数据
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);
	v.push_back(p5);
	v.push_back(p6);
	//遍历容器中的数据
	for (vector<Person>::iterator it = v.begin(); it != v.end(); it++){
		//cout << " 姓名： " << (*it).m_Name << "年龄： " << (*it).m_Age << endl;
		cout << " 姓名： " << it->m_Name << "年龄： " << it->m_Age << endl;
	}
}
//存放自定义数据类型的指针
static void test02(){
	vector<Person*> v;
	Person p1("aaa", 10);
	Person p2("bbb", 20);
	Person p3("ccc", 30);
	Person p4("ddd", 40);
	Person p5("eee", 50);
	Person p6("fff", 60);
	//向容器中添加数据
	v.push_back(&p1);
	v.push_back(&p2);
	v.push_back(&p3);
	v.push_back(&p4);
	v.push_back(&p5);
	v.push_back(&p6);
	//遍历容器
	for (vector<Person*>::iterator it = v.begin(); it != v.end(); it++){
		//cout << "姓名： " << (*(*it)).m_Name << "年龄： " << (*(*it)).m_Age << endl;
		cout << "姓名： " << (*it)->m_Name << "年龄：" << (*it)->m_Age << endl;
	}
}
int main()
{
	test02();
	system("pause");
	return 0;
}

188_22STL初识-容器嵌套容器

#include<iostream>
#include<string>
#include<vector>
using namespace std;
//容器嵌套容器
static void test(){
	vector<vector<int>> vv;
	//创建小容器
	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);
	}
	//将小容器插入到大的容器中
	vv.push_back(v1);
	vv.push_back(v2);
	vv.push_back(v3);
	vv.push_back(v4);
	//通过最大容器，把所有数据遍历一遍
	for (vector<vector<int>>::iterator it = vv.begin(); it != vv.end(); it++){
		//(*it)  --容器 vector<int>
		for (vector<int>::iterator vit = (*it).begin(); vit != (*it).end(); vit++){
			cout << *vit << "  ";
		}
		cout << endl;
	}
}
int main()
{
	test();
	system("pause");
	return 0;
}

189_23string容器-构造函数

string基本概念
本质：

string是C++风格的字符串，而string本质上是一个类
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各字符c初始化

#include<iostream>
#include<string>
using namespace std;
//string 的构造函数
static void test(){
	string s1;  //默认构造
	const char* str = "hello world";
	string s2(str);
	cout << "s2 = " << s2 << endl;
	string s3(s2);
	cout << "s3 = " << s3 << endl;
	string s4(10, 'a');
	cout << "s4 = " << s4 << endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

190_24string容器-赋值操作

赋值的函数原型：

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赋给当前字符串

#include<iostream>
#include<string>
using namespace std;
static void test(){
	string str1;
	str1 = "Hello World";
	cout << "str1 = " << str1 << endl;
	string str2;
	str2 = str1;
	cout << "str2 = " << str2 << endl;
	string str3;
	str3 = 'a';
	cout << "str3 = " << str3 << endl;
	string str4;
	str4.assign("Hello C++");
	cout << "str4 = " << str4 << endl;
	string str5;
	str5.assign("Hello C++", 5);
	cout << "str5 = " << str5 << endl;
	string str6;
	str6.assign(str5);
	cout << "str6 =" << str6 << endl;
	string str7;
	str7.assign(10, 'w');
	cout << "str7 = " << str7 << endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

191_25string容器-字符串拼接

实现字符串末尾拼接字符串
函数原型：

string& operator+=(const char*str);             //重载+=操作符
string& operator+=(const char c);               //重载+=操作符
string& operator+=(const string&str);           //重载+=操作符
string&append(const char *s);                   //把字符串s连接到当前字符串结尾
string&append(const char *s, int n);            //把字符串s的前n个字符串连接到当前字符串结尾
string&append(const string&s);                 //同operator+=(const char*str)
string&append(const string&s,int pos,int n);   //字符串s中从pos开始的n个字符连接到字符串结尾

#include<iostream>
#include<string>
using namespace std;
//string字符串拼接
static void test(){
	string str1 = "我";
	str1 += "爱玩游戏";
	cout << "str1 = " << str1 << endl;

	str1 += ':';
	cout << "str1 = " << str1 << endl;
	string str2 = " LOL DNF";
	str1 += str2;
	cout << "str1 = " << str1 << endl;

	string str3 = "I";
	str3.append(" love");
	cout << "str3 = " << str3 << endl;

	str3.append(" game abcde", 5);
	cout << "str3 = " << str3 << endl;

	str3.append(str2);
	cout << "str3 = " << str3 << endl;
	str3.append(str2, 0, 4);
	cout << "str3 = " << str3 << endl;
	str3.append(str2, 4, 4);
	cout << "str3 = " << str3 << endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

192_26string容器-字符串查找和替换

功能描述：

查找：查找指定字符串是否存在
替换：在指定的位置替换字符串
函数原型：

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

#include<iostream>
#include<string>
using namespace std;
//字符串的查找和替换
static void test(){
	string str1 = "abcdef";
	int pos = str1.find("de");
	if (pos == -1){
		cout << "未找到字符串：" << endl;
	}
	else{
		cout << "找到字符串，pos = " << pos << endl;
	}
	//rfind和find区别
	//rfind从右往左查找，find 从左往右查找
	pos = str1.rfind("de");
	cout << "找到字符串，pos = " << pos << endl;
}
//2、替换
static void test01(){
	string str1 = "abcdefg";
	//从1号位置起3个字符 替换为1111
	str1.replace(1, 3, "1111");
	cout << str1 << endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

总结：

find查找是从左往后，rfind从右往左
find找到字符串后返回查找的第一个字符位置，找不到返回-1
replace在替换时，要指定从那个位置起，多少个字符，替换成什么样的字符串

193_27string容器-字符串比较

功能描述：

字符串之间的比较

比较方式

字符串比较是按照字符的ASCII码进行对比

= 返回 0
> 返回 1
<返回 -1
函数原型：

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

#include<iostream>
#include<string>
using namespace std;
//字符串比较
static void test(){
	string str1 = "xello";
	string str2 = "hello";
	if (str1.compare(str2) == 0){
		cout << "str1 等于 str2 " << endl;
	}
	else if(str1.compare(str2)>0){
		cout << "str2 > str2" << endl;
	}
	else {
		cout << "str2 < str2" << endl;
	}
}
int main()
{
	test();
	system("pause");
	return 0;
}

总结：字符串对比主要是用于比较两个字符串是否相等，判断谁大谁小的意义并不大

194_28string容器-字符存取

string 中单个字符存取方式有两种

char &operator[](int n);     //通过[]方式取字符
char &at(int n);             //通过at方式获取字符

#include<iostream>
#include<string>
using namespace std;
//string 字符串存取

static void test(){
	string str = "hello";
	cout << "str = " << str << endl;
	//1、通过[]访问单个字符 
	for (int i = 0; i < str.size(); i++){
		cout << str[i] << " ";
	}
	cout << endl;
	//2、通过at方式访问单个字符
	for (int i = 0; i < str.size(); i++){
		cout << str.at(i) << " ";
	}
	cout << endl;

	//修改单个字符
	str[0] = 'x';
	cout << "str = " << str << endl;
	str.at(1) = 'x';
	cout << "str = " << str << endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

195_29string容器-字符串插入和删除

功能描述：

对string字符串进行插入和删除字符操作

函数原型：

string&insert(int pos, const char*s);       //插入字符串
string&insert(int pos,const string&str);    //插入字符串
string&insert(int pos,int n,char c);        //在指定位置插入n个字符c
string&erase(int pos, int n = npos);        //删除从pos开始的n给字符

#include<iostream>
#include<string>
using namespace std;
//字符串 插入和删除
static void test(){
	string str = "hello";
	str.insert(1, "111");
	cout << "str = " << str << endl;
	str.erase(1, 3);
	cout << "str = " << str << endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

196_30string容器-子串获取

功能描述：

从字符串中获取想要的子串

函数原型

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

#include<iostream>
#include<string>
using namespace std;
//string 求子串
static  void test(){
	string str = "abcdef";
	string subStr = str.substr(1, 3);
	cout << "subStr = " << subStr << endl;
}

//实用操作
static void test01(){
	string email = "zhangsan@sina.com";
	//从邮件地址中获取用户信息
	int pos = email.find("@");
	string useName = email.substr(0, pos);
	cout << useName << endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

197_31vector容器-构造函数

vector基本概念
功能：

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

vector与普通数组的区别：

不同之处在于数组是静态空间，而vector可以动态扩展

动态扩展：

并不是在原空间之后续接新空间，而是找到更大的内存空间，然后将原来数据拷贝到新空间，释放原来空间。
vector容器的迭代器是支持随机访问的迭代器

vector构造函数
功能描述：创建vector容器
函数原型：

vector<T> v;               //采用模板实现类实现，默认构造函数
vecotr(v.begin(),v.end()); //将v[begin(),end())区间中的元素拷贝给本身
vector(n,elem);            //构造函数将n个elem拷贝给本身
vector(const vector&vec);  //拷贝构造函数

#include<iostream>
#include<string>
#include<vector>
using namespace std;
static void printVector(const vector<int>&v){
	for (vector<int>::const_iterator it = v.begin(); it != v.end(); it++){
		cout << *it << " ";
	}
	cout << endl;
}
static void test(){
	vector<int> v1;    //默认构造，  无参构造
	for (int i = 0; i < 10; i++){
		v1.push_back(i);
	}
	printVector(v1);
	//通过区间方式进行构造
	vector<int>v2(v1.begin(), v1.end());
	printVector(v2);
	//n个elem方式构造
	vector<int> v3(10, 100);
	printVector(v3);
	//拷贝构造
	vector<int>v4(v3);
	printVector(v4);
}
int main()
{
	test();
	system("pause");
	return 0;
}

198_32vector容器-赋值操作

功能描述：
给vector容器进行赋值
函数原型：

vector& operator=(const vector &vec);    //重载符号操作符
assign(beg,end);                         //将[beg,end)区间中的数据拷贝赋值给本身
assign(n,elem);                          //将n个elem拷贝值给本身

#include<iostream>
#include<string>
#include<vector>
using namespace std;
static void printVector(const vector<int> &v){
	for (vector<int>::const_iterator it = v.begin(); it != v.end(); it++){
		cout << *it << "  ";
	}
	cout << endl;
}
//vector赋值
static void test(){
	vector<int> v1;
	for (int i = 0; i < 10; i++){
		v1.push_back(i);
	}
	printVector(v1);
	//赋值
	vector<int>v2;
	v2 = v1;
	printVector(v2);
	//assign
	vector<int>v3;
	v3.assign(v2.begin(), v2.end());
	printVector(v3);
	//n个elem方式
	vector<int> v4;
	v4.assign(10, 100);
	printVector(v4);
}
int main()
{
	test();
	system("pause");
	return 0;
}

总结：vector赋值方式比较简单，使用operator=，或者assign都可以

199_33vector容器-容量和大小

功能描述：
对vector容器的容量和大小操作
函数原型：

empty();           //判读容器是否为空
capacity();        //容器的容量
size();            //返回容器中元素的个数
resize(int num);   //重新指定容器的长度为num，若容器变长，则以默认值填充新的位置，如果容器变短，则末尾超出容器长度的元素被删除
resize(int num, elem);//重新指定容器的长度为num,若容器变长，则以elem值填充新位置，如果容器变短，则末尾超出容器长度的元素被删除

#include<iostream>
#include<string>
#include<vector>
using namespace std;
//vector 容器的容量和大小的操作
static void printVector(const vector<int>&v){
	for (vector<int>::const_iterator it = v.begin(); it != v.end(); it++){
		cout << *it << " ";
	}
	cout << endl;
}
static void test(){
	vector<int> v1;
	for (int i = 0; i < 10; i++){
		v1.push_back(i + 1);
	}
	printVector(v1);
	if (v1.empty()){   //  为真，代表容器为空
		cout << "v1为空" << endl;
	}
	else{
		cout << "v1不为空" << endl;
		cout << "v1的容量为：" << v1.capacity() << endl;
		cout << "v1的大小为：" << v1.size() << endl;
	}
	//重新指定大小
	v1.resize(15,100);
	printVector(v1);
	v1.resize(5);
	printVector(v1);
}
int main()
{
	test();
	system("pause");
	return 0;
}

总结：

判断是否为空 —empty
返回元素个数 —size
返回容器容量 —capacity
重新指定大小 —resize

200_34vector容器-插入和删除

功能描述：

对vector容器进行插入、删除操作

函数原型：

push_back(ele);                 //尾部插入元素ele
pop_back();                     //删除最后一个元素
insert(const_iterator pos, ele);//迭代器指向位置pos插入元素ele
insert(const_iterator pos,int count,ele);//迭代器指向位置pos插入count个元素ele
erase(const_iterator pos);      //删除迭代器指向的元素
erase(const_iterator start,const_iterator end);//删除迭代器从start到end之间的元素
clear();                        //删除容器中所有元素

#include<iostream>
#include<string>
#include<vector>
using namespace std;
//vector容器的插入和删除

static void printVector(const vector<int>&v){
	for (vector<int>::const_iterator it = v.begin(); it != v.end(); it++){
		cout << *it << " ";
	}
	cout << endl;
}
static void test(){
	vector<int> v1;
	for (int i = 1; i < 6; i++){
		v1.push_back(i * 10);
	}
	printVector(v1);
	//尾删
	v1.pop_back();
	printVector(v1);
	v1.insert(v1.begin(), 100);
	printVector(v1);
	v1.insert(v1.begin(),2, 1000);   //参数也是迭代器
	printVector(v1);
	v1.erase(v1.begin());   //参数也是迭代器
	printVector(v1);
	//清空
	v1.clear();
	//v1.erase(v1.begin(),v1.end());
	printVector(v1);
}
int main()
{
	test();
	system("pause");
	return 0;
}

总结：

尾插—push_back
尾删—pop_back
插入—insert(位置迭代器)
删除—erase(位置迭代器)
清空—clear

201_35vector容器-数据存取

功能描述：

对vector中的数据存取操作

函数原型：

at(int idx);       //返回索引idx所指的数据
operator[];        //返回索引idx所指的数据
front();           //返回容器中第一个数据元素
back();            //返回容器中最后一个数据元素

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

//vector容器，数据存取
static void printVector1(const vector<int> &v){//利用[]方式访问数组中元素
	for (int i = 0; i < v.size(); i++){
		cout << v[i] << " ";
	}
	cout << endl;
}

static void  printVector2(const vector<int>&v){ //利用at方式访问元素
	for (int i = 0; i < v.size(); i++){
		cout << v.at(i) << " ";
	}
	cout << endl;
}

static void printVector3(const vector<int>&v){ //利用迭代器访问数组元素
	for (vector<int>::const_iterator it = v.begin(); it != v.end(); it++){
		cout << *it << " ";
	}
	cout << endl;
}
static void test(){
	vector<int> v1;
	for (int i = 0; i < 10; i++){
		v1.push_back(i);
	}
	printVector1(v1);//利用[]方式访问数组中元素
	printVector2(v1);//利用at方式访问元素
	printVector3(v1);//利用迭代器访问数组元素
	//获取第一个元素
	cout << "第一个元素为：" << v1.front() << endl;
	cout << "最后一个元素为：" << v1.back() << endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

总结：
容器访问的三种方式

利用迭代器访问数组元素

static void printVector3(const vector<int>&v){ //利用迭代器访问数组元素
	for (vector<int>::const_iterator it = v.begin(); it != v.end(); it++){
		cout << *it << " ";
	}
	cout << endl;
}

利用at方式访问元素

static void  printVector2(const vector<int>&v){ //利用at方式访问元素
	for (int i = 0; i < v.size(); i++){
		cout << v.at(i) << " ";
	}
	cout << endl;
}

利用[]方式访问数组中元素

static void printVector1(const vector<int> &v){//利用[]方式访问数组中元素
	for (int i = 0; i < v.size(); i++){
		cout << v[i] << " ";
	}
	cout << endl;
}

front返回容器第一个元素
back返回容器最后一个元素

202vector容器-互换容器

功能描述：

实现两个容器内元素进行互换

函数原型：

swap(vec);    //将vec与本身的元素互换

#include<iostream>
#include<string>
#include<vector>
using namespace std;
static void printVector1(const vector<int>&v){
	for (vector<int>::const_iterator it = v.begin(); it != v.end(); it++){
		cout << *it << " ";
	}
	cout << endl;
}
static void printVector2(const vector<int>&v){
	for (int i = 0; i < v.size(); i++){
		cout << v[i] << " ";
	}
	cout << endl;
}
static void printVecotr3(const vector<int>&v){
	for (int i = 0; i < v.size(); i++){
		cout << v.at(i) << " ";
	}
	cout << endl;
}
//vector容器互换
//1、基本使用
static void test(){
	vector<int>v1;
	for (int i = 0; i < 10; i++){
		v1.push_back(i);
	}
	cout << "---------   交换前  ------" << endl;
	printVecotr3(v1);
	vector<int>v2;
	for (int i = 10; i > 0; i--){
		v2.push_back(i);
	}
	printVector2(v2);
	cout << "---------   交换后  ------" << endl;
	v1.swap(v2);
	printVector1(v1);
	printVector1(v2);
}
//2、实际的用途
//巧用swap可以收缩内存空间
static void test01(){
	vector<int>v;
	for (int i = 0; i < 10000; i++){
		v.push_back(i);
	}
	cout << "v的容量： " << v.capacity() << endl;
	cout << "v的大小：" << v.size() << endl;
	v.resize(3);  //重新指定大小
	cout << "v的容量： " << v.capacity() << endl;
	cout << "v的大小：" << v.size() << endl;
	//巧用swap收缩内存
	vector<int>(v).swap(v);
	cout << "v的容量： " << v.capacity() << endl;
	cout << "v的大小：" << v.size() << endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

在这里插入图片描述
总结：swap可以使两个容器互换，可以达到实用的收缩内存效果

203_37vector容器-预留空间

功能描述：

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

函数原型

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

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

//vecotr容器  预留空间
static void test(){
	vector<int> v;
	//利用reserve预留空间
	v.reserve(100000);
	int num = 0;  //统计开辟次数
	int *p = nullptr;
	for (int i = 0; i < 100000; i++){
		v.push_back(i);
		if (p != &v[0]){
			p = &v[0];
			num++;
		}
	}
	cout << "num = " << num << endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

总结：如果数据量较大，可以一开始利用reserve预留空间

204_38deque容器-构造函数

功能描述：

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

deque与vector区别：

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

deque内部工作原理：
deque内部有个中控器，维护每段缓冲区中的内容，缓冲区中存放真实的数据，中控器维护的是每个缓冲区的地址，使得使用deque时像一边连续的内存空间。
deque容器的迭代器也是支持随机访问的

deque构造函数
功能描述：

deque容器构造

函数原型：

deque<T> deq;               //默认构造形式
deque(beg,end);             //构造函数将[beg,end)区间中的元素拷贝给本身
deque(n,elem);              //构造函数将n个elem拷贝给本身
deque(const deque&deq);     //拷贝构造函数

#include<iostream>
#include<string>
#include<deque>
//构造函数
using namespace std;
static void printDeque1(const deque<int>&de){
	for (deque<int>::const_iterator it = de.begin(); it != de.end(); it++){
		cout << *it << " ";
	}
	cout << endl;
}
static void printDeque2(const deque<int>&de){
	for (int i = 0; i < de.size(); i++){
		cout << de[i] << " ";
	}
	cout << endl;
}
static void printDeque3(const deque<int>&de){
	for (int i = 0; i < de.size(); i++){
		cout << de.at(i) << " ";
	}
	cout << endl;
}
static void test(){
	deque<int>d1;
	for (int i = 0; i < 10; i++){
		d1.push_back(i);
	}
	printDeque1(d1);
	printDeque2(d1);
	printDeque3(d1);
	deque<int>d2(d1.begin(), d1.end());
	printDeque1(d2);
	deque<int>d3(10, 100);
	printDeque2(d3);
	deque<int>d4(d3);
	printDeque3(d4);
}
int main()
{
	test();
	system("pause");
	return 0;
}

205_39deque容器-赋值操作

功能描述：

deque容器进行赋值

函数原型：

deque&operator=(const deque &deq);     //重载等号操作符
assign(beg,end);                       //将[beg,end)区间中的数据拷贝赋值给本身
assign(n,elem);                        //将n个elem拷贝赋值给本身

#include<iostream>
#include<string>
#include<deque>
using namespace std;
//deque容器赋值操作
static void printDeque1(const deque<int>&d){
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++){
		cout << *it << " ";
	}
	cout << endl;
}
static void printDeque2(const deque<int>&d){
	for (int i = 0; i < d.size(); i++){
		cout << d[i] << " ";
	}
	cout << endl;
}
static void printDeque3(const deque<int>&d){
	for (int i = 0; i < d.size(); i++){
		cout << d.at(i) << " ";
	}
	cout << endl;
}
static void test(){
	deque<int> d1;
	for (int i = 0; i < 10; i++){
		d1.push_back(i);
	}
	printDeque1(d1);
	//operator= 
	deque<int> d2;
	d2 = d1;
	printDeque2(d2);
	//assign
	deque<int>d3;
	d3.assign(d1.begin(), d1.end());
	printDeque3(d3);
	deque<int> d4;
	d4.assign(10, 100);
	printDeque3(d4);
}
int main()
{
	test();
	system("pause");
	return 0;
}

206_40deque容器-大小操作

功能描述：

deque容器的大小进行操作

函数原型：

deque.empty();       //判断容器是否为空
deque.size();        //返回容器中元素的个数
deque.resize(num);   //重新指定容器的长度为num，若容器变长，则以默认值填充新的位置。如果容器变短，则末尾超出容器长度的元素被删除
deque.resize(num,elem); //重新指定容器的长度为num，若容器变长，则以elem值填充新位置，如果容器变短，则末尾超出容器长度的元素被删除。

#include<iostream>
#include<string>
#include<deque>
using namespace std;
static void printDeque1(const deque<int>&d){
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++){
		cout << *it << " ";
	}
	cout << endl;
}
static void printDeque2(const deque<int>&d){
	for (int i = 0; i < d.size(); i++){
		cout << d[i] << " ";
	}
	cout << endl;
}

static void printDeque3(const deque<int> &d){
	for (int i = 0; i < d.size(); i++){
		cout << d.at(i) << " ";
	}
	cout << endl;
}

static void test(){
	deque<int> d;
	for (int i = 0; i < 10; i++){
		d.push_front(i);
	}
	printDeque1(d);
	if (d.empty()){
		cout << "d为空" << endl;
	}
	else{
		cout << "d不为空" << endl;
		cout << "d的大小为： " << d.size() << endl;
	}
	//重新指定大小
	d.resize(13);
	printDeque2(d);
	d.resize(15, 1);
	printDeque3(d);
}
int main()
{
	test();
	system("pause");
	return 0;
}

总结：

deque没有容量的概念
判断是否为空 -----empty
返回元素个数 ------size
重新只当个数 -----resize

207_41deque容器-插入和删除

功能描述：

向deque容器中插入和删除数据

函数原型：
两端插入操作：

push_back(elem);      //在容器尾部添加一个数据
push_front(elem);     //在容器头部插入一个数据
pop_back();           //删除容器最后一个数据
pop_front();          //删除容器第一个数据

指定位置操作：

insert(pos ,elem);      //在pos位置插入一个elem元素的拷贝，返回新数据的位置
insert(pos,n,elem);     //在pos位置插入n个elem元素数据，无返回值
insert(pos,beg,end);    //在pos位置插入[beg,end)区间的数据，无返回值
clear();                //清空容器的所有数据
erase(beg,end);         //删除[beg,end)区间的数据，返回下一个数据的位置
erase(pos);             //删除pos位置的数据，返回下一个数据的位置

#include<iostream>
#include<string>
#include<deque>
using namespace std;
//deque容器的插入和删除
static void printDeque1(const deque<int>&d){
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++){
		cout << *it << " ";
	}
	cout << endl;
}

static void printDeque2(const deque<int>&d){
	for (int i = 0; i < d.size(); i++){
		cout << d[i] << " ";
	}
	cout << endl;
}
static void printDeque3(const deque<int>&d){
	for (int i = 0; i < d.size(); i++){
		cout << d.at(i) << " ";
	}
	cout << endl;
}

static void test(){
	deque<int>dq;
	dq.push_back(10);
	dq.push_back(20);
	dq.push_front(100);
	dq.push_front(200);
	printDeque1(dq);
	//尾删
	dq.pop_back();
	printDeque2(dq);
	dq.pop_front();
	printDeque3(dq);
}

static void test01(){
	deque<int>dq;
	dq.push_back(10);
	dq.push_back(20);
	dq.push_front(100);
	dq.push_front(200);
	printDeque1(dq);
	//insert
	dq.insert(dq.begin(), 1000);
	printDeque1(dq);
	dq.insert(dq.begin(),2, 1000);
	printDeque1(dq);
	//按照区间
	deque<int> d2;
	d2.push_back(1);
	d2.push_back(2);
	d2.push_back(3);
	dq.insert(dq.begin(), d2.begin(), d2.end());
	printDeque1(dq);
}

static void test02(){
	deque<int>dq;
	dq.push_back(10);
	dq.push_back(20);
	dq.push_front(100);
	dq.push_front(200);
	//删除
	deque<int>::iterator it = dq.begin();
	it++;
	dq.erase(it);
	printDeque1(dq);
	//按照区间的方式删除
	dq.clear();
	dq.erase(dq.begin(), dq.end());
	printDeque1(dq);
}
int main()
{
	test02();
	system("pause");
	return 0;
}

总结：

插入和删除提供的位置是迭代器
尾插 —push_back
尾删 —pop_back
头插 —push_front
头删 —pop_front

208_42deque容器-数据存取

功能描述：

对deque中的数据存取操作

函数原型：

at(int idx);          //返回索引idx所指的数据
operator[];           //返回索引idx所指的数据
front();              //返回容器中第一个数据元素
back();               //返回容器中最后一个数据元素

#include<iostream>
#include<string>
#include<deque>
using namespace std;
//deque容器数据存取
static void printDeque1(const deque<int>&q){
	for (deque<int>::const_iterator it = q.begin(); it != q.end(); it++){
		cout << *it << " ";
	}
	cout << endl;
}
static void pirntDeque2(const deque<int>&q){
	for (int i = 0; i < q.size(); i++){
		cout << q[i] << " ";
	}
	cout << endl;
}
static void printDeque3(const deque<int>&q){
	for (int i = 0; i < q.size(); i++){
		cout << q.at(i) << " ";
	}
	cout << endl;
}
static void test(){
	deque<int> d;
	d.push_back(10);
	d.push_back(20);
	d.push_back(30);
	d.push_front(100);
	d.push_front(200);
	d.push_front(300);
	printDeque3(d);
}
int main()
{
	test();
	system("pause");
	return 0;
}

总结：
容器访问的三种方式

利用迭代器访问数组元素

static void printDeque1(const deque<int>&q){
	for (deque<int>::const_iterator it = q.begin(); it != q.end(); it++){
		cout << *it << " ";
	}
	cout << endl;
}

利用[]访问数组元素

static void pirntDeque2(const deque<int>&q){
	for (int i = 0; i < q.size(); i++){
		cout << q[i] << " ";
	}
	cout << endl;
}

利用at访问数组元素

static void printDeque3(const deque<int>&q){
	for (int i = 0; i < q.size(); i++){
		cout << q.at(i) << " ";
	}
	cout << endl;
}

209_43deque容器-排序操作

功能描述：

利用算法实现对deque容器进行排序

算法

sort(iterator beg,iterator end)   //对beg和end区间内元素进行排序

#include<iostream>
#include<string>
#include<queue>
#include<algorithm>
using namespace std;
static void printDeque1(const deque<int>&d){
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++){
		cout << *it << " ";
	}
	cout << endl;
}
static void printDeque2(const deque<int>&d){
	for (int i = 0; i < d.size(); i++){
		cout << d[i] << " ";
	}
	cout << endl;
}
static void printDeque3(const deque<int>&d){
	for (int i = 0; i < d.size(); i++){
		cout << d.at(i) << "  ";
	}
	cout << endl;
}
//deque容器排序
static void test(){
	deque<int>d;
	d.push_back(10);
	d.push_front(20);
	d.push_back(12);
	d.push_front(30);
	d.push_front(40);
	d.push_front(50);
	printDeque1(d);
	//对于支持随机访问的迭代器的容器，都可以利用sort算法直接对其进行排序
	sort(d.begin(), d.end());
	cout << "排序后 --" << endl;
	printDeque1(d);
}
int main()
{
	test();
	system("pause");
	return 0;
}

211_45stack容器-基本概念

概念：stack是一种先进后出的数据结构(First In Last Out),它只有一个出口
在这里插入图片描述
栈中只有顶端的元素才可以被外界使用，因此栈不允许有遍历行为。
栈中进入数据称为 —入栈push
栈中弹出数据称为 —出栈pop

212_46stack容器-常用接口

功能描述：栈容器常用的对外接口
构造函数：

stack<T> stk;            //stack采用模板类实现，stack对象的默认构造形式
stack(const stack&stk);  //拷贝构造函数

赋值操作：

push(elem);       //向栈顶添加元素
pop();            //从栈顶移除第一个元素
top();            //返回栈顶元素

大小操作：

empty();         //判断堆栈是否为空
size();          //返回栈的大小

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

//栈stack容器
static void test() {
	//特点符合先进后出的数据结构
	stack<int> s;
	//入栈
	s.push(10);
	s.push(20);
	s.push(30);
	s.push(40);
	//只要栈不为空，查看栈顶，并且执行出栈操作
	while (!s.empty()) {
		//查看栈顶的元素
		cout << "栈顶的元素为：" << s.top() << endl;
		//出栈
		s.pop();
	}
	cout << "栈的大小：" << s.size() << endl;
}
int main() 
{
	test();
	system("pause");
	return 0; 
}

总结：

入栈 —push
出栈 —pop
返回栈顶 —top
判断栈是否为空 —empty
返回栈大小 —size

213_47queue容器-基本概念

概念：queue是一种先进先出（First In First Out)的数据结果
在这里插入图片描述
队列容器允许从一端新增元素，从另一端移除元素
队列中只有队头和队尾才可以被外界使用，因此队列不允许有遍历行为
队列中进数据称为 —入队 push
队列中出数据称为 —出队 pop

214_48queue容器-常用接口

功能描述：栈容器常用的对外接口
构造函数

queue<T> que;                //queue采用模板类实现，queue对象的默认构造形式
queue(const queue &que);     //拷贝构造函数

赋值操作：

queue& operator=(const queue&que);    //重载等号操作符

数据存取

push(elem);             //往队尾添加元素
pop();                  //从队头移除第一个元素
back();                 //返回最后一个元素
front();                //返回第一个元素

大小操作：

empty();              //判断堆栈是否为空
size();               //返回栈的大小

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

//队列 queue
class Person {
public:
	Person(string name, int age):m_Name(name),m_Age(age) {

	}
	string m_Name;
	int m_Age;
};
static void test() {
	//创建队列
	queue<Person> q;
	//准备数据
	Person p1("唐僧", 30);
	Person p2("孙悟空", 800);
	Person p3("猪八戒", 1000);
	Person p4("沙僧", 900);
	//入队
	q.push(p1);
	q.push(p2);
	q.push(p3);
	q.push(p4);
	//判断只要队列不为空，查看队头，查看队尾，  出队
	while (!q.empty()){
		//查看队头
		cout << "队头元素   ---姓名：" << q.front().m_Name << "\t 年龄：" << q.front().m_Age << endl;
		//查看队尾
		cout << "队尾元素   ---姓名：" << q.back().m_Name << "\t 年龄：" << q.back().m_Age << endl;
		//出队
		q.pop();
	}
	cout << "队列的大小为：" << q.size() << endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

入队 —push
出队 —pop
返回队头元素 —front
返回队尾元素 —back
判断队是否为空 —empty
返回队列大小 —size

215_49list容器-基本概念

list基本概念
功能：将数据进行链式存储
链表：是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的
链表的组成：链表由一系列结点组成
结点的组成：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域
STL中的链表是一个双向循环链表
在这里插入图片描述
由于链表的存储方式并不是连续的内存空间，因此链表list中的迭代器只支持前移和后移，属于双向迭代器。
list的优点：

采用动态存储分配，不会造成内存浪费和溢出
链表执行插入和删除操作十分便捷，修改指针即可，不需要移动大量元素

list的缺点：

链表灵活，但是空间（指针域）和时间（遍历）额外耗费较大

list有一个重要的性质，插入操作和删除操作都不会造成原有list迭代器的失效，这在vector是不成立的。
总结：STL中list和vector是有两个最常被使用的容器，各有优缺点。

在这里插入图片描述

216_50list容器-构造函数

功能描述：

创建list容器

函数原型：

list<T> lst;              //list采用模板类实现对象的默认构造形式
list(beg,end);            //构造函数将[beg,end)区间中的元素拷贝给本身
list(n,elem);             //构造函数将n个elem拷贝给本身
list(const list &lst);    //拷贝构造函数

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

//list容器的构造函数
static void printList1(const list<int>& L) {
	for (list<int>::const_iterator it = L.begin(); it != L.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

static void test() {
	list<int>L1;
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);
	//遍历容器
	printList1(L1);
	//区间构造方式构造
	list<int>L2(L1.begin(), L1.end());
	printList1(L2);
	//拷贝构造
	list<int>L3(L2);
	printList1(L3);
	//n个elem
	list<int>L4(10, 1000);
	printList1(L4);
}
int main()
{
	test();
	system("pause");
	return 0;
}

217_51list容器-赋值和交换

功能描述：

个list容器进行赋值，以及交换list容器

函数原型：

assign(beg,end);                          //将[beg,end)区间中的数据拷贝赋值给本身
assign(n,elem);                           //将n个elem拷贝赋值给本身
list& operator=(const list &lst);         //重载等号操作符
swap(lst);                                //将lst与本身的元素互换

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

//list容器赋值和替换
static void printList(const list<int>& L) {
	for (list<int>::const_iterator it = L.begin(); it != L.end(); ++it) {
		cout << *it << " ";
	}
	cout << endl;
}
//赋值
static void test() {
	list<int> L1;
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);
	printList(L1);
	
	list<int> L2;
	L2 = L1;     //operator=赋值
	printList(L2);
	list<int>L3;
	L3.assign(L2.begin(), L2.end());
	printList(L3);
	list<int>L4;
	L4.assign(10, 1000);
	printList(L4);
}

//交换
static void test01() {
	list<int> L1;
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);
	printList(L1);

	list<int>L2;
	L2.assign(10, 100);
	cout << "--------------交换前-------------" << endl;
	printList(L1);
	printList(L2);
	cout << "--------------交换后-------------" << endl;
	L1.swap(L2);
	printList(L1);
	printList(L2);

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

218_52list容器-大小操作

功能描述：

对list容器的大小进行操作

函数原型：

size();                        //返回容器中元素的个数
empty();                       //判断容器是否为空
resize(num);                   //重新指定容器的长度为num，若容器变长，则以默认值填充新位置，如果容器变短，则末尾超出容器长度的元素被删除
resize(num,elem);             //重新指定容器的长度为num，若容器变长，则以elem值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除

#include<iostream>
#include<string>
#include<list>
using namespace std;
//list容器大小操作
static void printList(const list<int>& L) {
	for (list<int>::const_iterator it = L.begin(); it != L.end(); ++it) {
		cout << *it << " ";
	}
	cout << endl;
}

static void test() {
	list<int>L1;
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);
	printList(L1);
	if (L1.empty()) {
		cout << "L1为空" << endl;
	}
	else {
		cout << "L1不为空" << endl;
		cout << "L1的元素个数为：" << L1.size() << endl;
	}

	//重新指定大小
	L1.resize(10);
	printList(L1);
	L1.resize(20,100);
	printList(L1);
}
int main()
{
	test();
	system("pause");
	return 0;
}

总结：

判断是否为空 —empty
返回元素个数 —size
重新指定个数 —resize

219_53list容器-插入和删除

功能描述：

对list容器进行数据的插入和删除

函数原型：

push_back(elem);                       //在容器尾部加入一个元素
pop_back();                            //删除容器中最后一个元素
push_front(elem);                      //在容器开头插入一个元素
pop_front();                           //从容器开头移除第一个元素
insert(pos,elem);                      //在pos位置插elem元素的拷贝，返回新数据的位置
insert(pos,n,elem);                    //在pos位置插入n个elem数据，无返回值
insert(pos,beg,end);                   //在pos位置插入[beg,end)区间的数据，无返回值
clear();                               //移除容器的所有数据
erase(beg,end);                        //删除[beg,end)区间的数据，返回下一个数据的位置
erase(pos);                            //删除pos位置的数据，返回下一个数据的位置
remove(elem);                          //删除容器中所有与elem值匹配的元素

#include<iostream>
#include<string>
#include<list>
using namespace std;
//list容器的插入和删除
inline void printList(const list<int>& L) {
	for (list<int>::const_iterator it = L.begin(); it != L.end(); ++it) {
		cout << *it << " ";
	}
	cout << endl;
}
static void test() {
	list<int>L;
	//尾插
	L.push_back(10);
	L.push_back(20);
	L.push_back(30);
	//头插
	L.push_front(40);
	L.push_front(50);
	L.push_front(60);
	printList(L);
	//尾删
	L.pop_back();
	printList(L);
	//头删
	L.pop_front();
	printList(L);
	//insert插入
	L.insert(L.begin(), 1000);
	printList(L);
	list<int>::iterator it = L.begin();
	L.insert(++it, 200);
	printList(L);
	//删除
	it = L.begin();
	L.erase(++it);
	printList(L);
	//移除
	L.push_back(1111);
	L.push_back(1111);
	L.push_back(1111);
	printList(L);
	L.remove(1111);
	printList(L);
	//清空
	L.clear();
	printList(L);
}
int main()
{
	test();
	system("pause");
	return 0;
}

总结：

尾插 —push_back
尾删 —pop_back
头插 —push_front
头删 —pop_front
插入 —insert
删除 —erase
移除 —remove
清空 —clear

220_54list容器-数据存取

功能描述：

对list容器中数据进行存取

函数原型：

front();              //返回第一个元素
back();               //返回最后一个元素

#include<iostream>
#include<string>
#include<list>
using namespace std;
//list容器    数据存取

static void test() {
	list<int> L1;
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);
	//L1[0]  L1.at(0)  不可以用list访问容器中的元素
	//原因是list本质是链表，不是用连续线性空间存储数据，迭代器也不支持随机访问
	cout << "第一个元素为：" << L1.front() << endl;
	cout << "最后一个元素为：" << L1.back() << endl;
	//验证迭代器是不支持随机访问的
	list<int>::iterator it = L1.begin();
	it++;            //支持双向
	//it = it + 2;   //不支持
}
int main()
{
	test();
	system("pause");
	return 0;
}

总结：

list容器中不可以通过[]或者at方式访问数据
返回第一个元素 —front
返回最后一个元素 —back

221_55list容器-反转和排序

功能描述：

将容器中的元素反转，以及将容器中的数据进行排序

函数原型：

reverse();               //反转链表
sort();                  //链表排序

#include<iostream>
#include<string>
#include<algorithm>
#include<list>
using namespace std;
//list容器反转和排序
static inline void printList(const list<int>& L) {
	for (list<int>::const_iterator it = L.begin(); it != L.end(); ++it) {
		cout << *it << " ";
	}
	cout << endl;
}
static void test() {
	//反转
	list<int> L1;
	for (int i = 1; i < 5; i++) {
		L1.push_back(10 * i);
	}
	cout << "反转前： -----------" << endl;
	printList(L1);
	cout << "反转后： ----------" << endl;
	L1.reverse();
	printList(L1);
}

inline bool myCompare(int v1,int v2) {
	return v1 > v2;
}
//排序
static inline void test01() {
	list<int> L1;
	for (int i = 1; i < 5; i++) {
		L1.push_back(10 * i);
		L1.push_front(9 * i);
	}
	cout << "排序前 --------" << endl;
	printList(L1);
	//所有不支持随机访问迭代器的容器，不可以用标准算法
	//不支持随机访问迭代器的容器，内部会提供对应的一些算法
	//sort(L1.begin(), L1.end());
	cout << "排序后 ---------" << endl;
	L1.sort();    //默认排序规则，从小到大
	printList(L1);
	L1.sort(myCompare);    
	printList(L1);

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

总结：

反转 —reverse
排序 —sort(成员函数)

222_56list容器-排序案例

案例描述：将Person自定义数据类型进行排序，Person中属性有姓名、年龄、身高
排序规则：按照年龄进行升序，如果年龄相同按照身高进行降序

#include<iostream>
#include<string>
#include<list>
using namespace std;
class Person {
public:
	Person(string name, int age, int height) :m_Name(name), m_Age(age), m_Height(height) {
	}
	string m_Name;
	int m_Age;
	int m_Height;
};
static inline void printList(const list<Person>& L) {
	for (list<Person>::const_iterator it = L.begin(); it != L.end(); ++it) {
		cout << "姓名： " << (*it).m_Name << "\t年龄：" << it->m_Age << "\t身高：" << it->m_Height << endl;
	}
}
//指定排序规则
inline bool comparePerson(Person& p1, Person& p2) {
	//按照年龄  升序
	if (p1.m_Age == p2.m_Age) {
		return p1.m_Height > p2.m_Height;
	}
	else {
		return p1.m_Age < p2.m_Age;
	}
}
static inline void test() {
	list<Person> L;     //创建容器
	//准备数据
	Person p1("刘备", 35, 175);
	Person p2("曹操", 45, 180);
	Person p3("孙权", 20, 178);
	Person p4("赵云", 25, 190);
	Person p5("张飞", 35, 180);
	Person p6("关羽", 35, 190);
	//插入数据
	L.push_back(p1);
	L.push_back(p2);
	L.push_back(p3);
	L.push_back(p4);
	L.push_back(p5);
	L.push_back(p6);
	printList(L);
	cout << "---------------------" << endl;
	cout << "排序后：" << endl;
	L.sort(comparePerson);
	printList(L);
}
int main()
{
	test();
	system("pause");
	return 0;
}

总结：

对于自定义数据类型，必须要指定排序规则，否则编译器不知道如何进行排序
高级排序只是在排序规则上在进行一次逻辑规则制定，并不复杂

223_57set容器-构造和赋值

简介：

所有元素都会在插入时自动被排序

本质

set/multiset属于关联式容器，底层结构是用二叉树实现

set和multiset区别：

set不允许容器中有重复的元素
multiset允许容器中有重复的元素

set构造和赋值
构造：

set<T> st;            //默认构造函数
set(const set &st);   //拷贝构造函数

赋值

set& operator=(const set &st);        //重载等号操作符

#include<iostream>
#include<string>
#include<set>
using namespace std;
//set容器的构造和赋值
static inline void printSet(const set<int>& s) {
	for (set<int>::const_iterator it = s.begin(); it != s.end(); ++it) {
		cout << *it << " ";
	}
	cout << endl;
}
static inline void test() {
	set<int> s1;
	//插入数据，只有insert方式
	s1.insert(10);
	s1.insert(10);
	s1.insert(10);
	s1.insert(50);
	s1.insert(20);
	s1.insert(30);
	s1.insert(40);
	//遍历容器
	//set容器的特点，所有元素插入时候会自动被排序
	//set容器不允许插入重复值
	printSet(s1);
	//拷贝构造
	set<int>s2(s1);
	printSet(s2);
	//赋值
	set<int> s3;
	s3 = s2;
	printSet(s3);
}
int main()
{
	test();
	system("pause");
	return 0;
}

总结：

set容器插入数据时用insert
set容器插入数据会自动排序

224_58set容器-大小和交换

功能描述：

统计set容器大小以及交换set容器

函数原型：

size();             //返回容器中元素的数目
empty();            //判断容器是否为空
swap(st);           //交换两个集合容器

#include<iostream>
#include<string>
#include<set>
using namespace std;
//set容器  大小和交换
static inline void printSet(const set<int>& st) {
	for (set<int>::const_iterator it = st.begin(); it != st.end(); ++it) {
		cout << *it << " ";
	}
	cout << endl;
}
//大小
static inline void test01() {
	set<int> st;
	st.insert(10);
	st.insert(30);
	st.insert(20);
	st.insert(40);
	printSet(st);
	//判断是否为空
	if (st.empty()) {
		cout << "st为空" << endl;
	}
	else {
		cout << "st不为空" << endl;
		cout << "st的大小为：" << st.size() << endl;
	}
}

//交换
static inline void test02() {
	set<int> st;
	st.insert(10);
	st.insert(30);
	st.insert(20);
	st.insert(40);
	
	set<int> st2;
	st2.insert(100);
	st2.insert(300);
	st2.insert(200);
	st2.insert(400);
	cout << "交换前：  " << endl;
	printSet(st);
	printSet(st2);
	cout << "交换后： " << endl;
	st.swap(st2);
	printSet(st);
	printSet(st2);
}

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

总结：

统计大小 —size
判断是否为空 —empty
交换容器 —swap

225_59set容器-插入和删除

功能描述：

set容器进行插入数据和删除数据

函数原型：

insert(elem);               //在容器中插入元素
clear();                    //清除所有元素
erase(pos);                 //删除pos迭代器所指的元素，返回下一个元素的迭代器
erase(beg,end);             //删除区间[beg,end)的所有元素，返回下一个元素的迭代器
erase(elem);                //删除容器中值为elem的元素

#include<iostream>
#include<string>
#include<set>
using namespace std;
//set容器的插入和删除
static inline void printSet(const set<int>& st) {
	for (set<int>::const_iterator it = st.begin(); it != st.end(); ++it) {
		cout << *it << " ";
	}
	cout << endl;
}
static inline void test() {
	set<int>st;
	//插入
	st.insert(10);
	st.insert(20);
	st.insert(40);
	st.insert(30);
	//遍历
	printSet(st);
	//删除
	st.erase(st.begin());
	printSet(st);
	st.erase(30);
	printSet(st);
	st.erase(st.begin(), st.end());
	printSet(st);
	st.clear();
	printSet(st);
}
int main()
{
	test();
	system("pause");
	return 0;
}

总结：

插入 — insert
删除 —erase
清空 —clear

226_60set容器-查找和统计

功能描述：

对set容器进行查找数据以及统计数据

函数原型：

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

#include<iostream>
#include<string>
#include<set>
using namespace std;
//set容器  查找和统计

static inline void test(){
	//查找
	set<int> st;
	for (int i = 1; i < 5; i++) {
		st.insert(10 *i);
	}
	set<int>::iterator pos = st.find(300);
	if (pos != st.end()) {
		cout << "找到元素为：" << *pos << "的值" << endl;
	}
	else {
		cout << "未找到元素：" << endl;
	}
}
//统计
static inline void test02() {
	set<int> st;
	for (int i = 1; i < 5; i++) {
		st.insert(10 * i);
	}
	//统计30的个数
	int num = st.count(30);
	//对于set而言，统计的结果要么是0  要么是1
	cout << "num = " << num << endl;
}

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

总结：

查找 —find（返回的是迭代器）
统计 —count(对于set,结果为0或者1)

227_61set容器-set和multiset区别

区别：

set不可以插入重复数据，而multiset可以
set插入数据的同时会返回插入结果，表示插入是否成功
multiset不会检测数据，因此可以插入重复数据

#include<iostream>
#include<string>
#include<set>
using namespace std;
//set容器和multiset容器的区别

static inline void test() {
	set<int>s;
	pair<set<int>::iterator,bool> ret =s.insert(10);
	if (ret.second) {
		cout << "first insert succeed" << endl;
	}
	else {
		cout << "first insert failed" << endl;
	}
	s.insert(10);
	if (ret.second) {
		cout << "second insert succeed" << endl;
	}
	else {
		cout << "second insert failed" << endl;
	}
	multiset<int>ms;
	//允许插入重复值
	ms.insert(10);
	ms.insert(10);
	for (multiset<int>::iterator it = ms.begin(); it != ms.end(); ++it) {
		cout << *it << " ";
	}
	cout << endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

总结：

如果不允许插入重复数据可以利用set
如果需要插入重复数据利用multiset

228_62pair使用-pair对组的创建

功能描述：

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

两种创建方式：

pair<type,type>p(value1,value2);
pair<type,type>p= make_pair(value1,value2);

#include<iostream>
#include<string>
using namespace std;
static inline void test() {
	//第一种方式
	pair<string, int>p("Tom", 20);
	cout << "姓名： " << p.first << "年龄： " << p.second << endl;
	//第二种方式
	pair<string, int>p2 = make_pair("Jerry", 30);
	cout << "姓名： " << p.first << "年龄：" << p.second << endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

229_63set容器-内置类型指定排序规则

主要技术点：

利用仿函数，可以改变排序规则

#include<iostream>
#include<string>
#include<set>
using namespace std;
//set容器的排序
//指定排序规则
class myCompare {
public:
	bool operator()( int v1,  int v2)const{
		return v1 > v2;
	}
};
static inline void printSet(const set<int>& st) {
	for (set<int>::const_iterator it = st.begin(); it != st.end(); ++it) {
		cout << *it << " ";
	}
	cout << endl;
}
static inline void printSet1(const set<int,myCompare>& st) {
	for (set<int,myCompare>::const_iterator it = st.begin(); it != st.end(); ++it) {
		cout << *it << " ";
	}
	cout << endl;
}
static inline void test() {
	set<int>st;
	for (int i = 1; i < 5; i++) {
		st.insert(10 * i);
	}
	printSet(st);
	set<int,myCompare>st2;
	st2.insert(100);
	st2.insert(300);
	st2.insert(200);
	st2.insert(400);
	printSet1(st2);
}
int main()
{
	test();
	system("pause");
	return 0;
}

230_64set容器-自定义数据类型指定排序规则

学习目标：

set容器默认排序规则为从小到大，掌握如何改变排序规则

主要技术：

利用仿函数，可以改变排序规则

#include<iostream>
#include<string>
#include<set>
using namespace std;
//set容器排序，存放自定义数据类型
class Person {
public:
	Person(string name, int age):m_Name(name),m_Age(age) {

	}
	string m_Name;
	int m_Age;
};

class comparePerson {
public:
	bool operator()(const Person& p1, const Person& p2) const{
		return p1.m_Age < p2.m_Age;
	}
};

static void inline test() {
	//自定义数据类型，都会指定排序规则
	set<Person, comparePerson> s;
	//创建Person对象
	Person p1("刘备", 39);
	Person p2("关羽", 28);
	Person p3("张飞", 25);
	Person p4("赵云", 21);
	s.insert(p1), s.insert(p2), s.insert(p3), s.insert(p4);
	for (set<Person, comparePerson>::iterator it = s.begin(); it != s.end(); ++it) {
		cout << "姓名： " << (*it).m_Name << " \t年龄：" << it->m_Age << endl;
	}
}
int main()
{
	test();
	system("pause");
	return 0;
}

231_65map容器-构造和赋值

map基本概念
简介：

map中所有元素都是pair
pair中第一个元素为key（键值），起到索引作用，第二个元素为value(实值)
所有元素都会根据元素的键值自动排序

本质：

map/multimap数据关联式容器，底层结构是用二叉树实现

优点：

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

map和multimap区别：

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

功能描述：

对map容器进行构造和赋值操作

函数原型：

map<T1,T2> mp;      //map默认构造函数：
map<const map&mp);  //拷贝构造函数

赋值：

map& operator=(const map &mp);  //重载等号操作符

#include<iostream>
#include<string>
#include<map>
using namespace std;
//map容器  构造和赋值
static inline void printMap(const map<int, int>& m) {
	for (map<int, int>::const_iterator it = m.begin(); it != m.end(); ++it) {
		cout << "key = " << it->first << "\tvalue = " << (*it).second << endl;
	}
}
static inline void test() {
	map<int, int>mp;
	mp.insert(pair<int, int>(1, 10));
	mp.insert(pair<int, int>(2, 20));
	mp.insert(pair<int, int>(4, 30));
	mp.insert(pair<int, int>(3, 40));
	mp.insert(pair<int, int>(5, 50));
	printMap(mp);

	//拷贝构造
	cout << "拷贝构造--------------" << endl;
	map<int, int>m2(mp);
	printMap(m2);
	//赋值
	cout << "赋值-------------------" << endl;
	map<int, int> m3;
	m3 = mp;
	printMap(m3);
}
int main()
{
	test();
	system("pause");
	return 0;
}

总结：map中所有元素都是成对出现，插入数据时侯要使用对组

232_66map容器-大小和交换

功能描述：

统计map容器大小以及交换map容器

函数原型：

size();              //返回容器中元素的数目
empty();             //判断容器是否为空
swap(st);            //交换两个集合容器

#include<iostream>
#include<string>
#include<map>
using namespace std;
//map容器  大小和交换

static inline void printMap(const map<int, int>& mp) {
	for (map<int, int>::const_iterator it = mp.begin(); it != mp.end(); ++it) {
		cout << "key值为：" << (*it).first << "\tvalue的值为：" << it->second << endl;
	}
}
//大小
static inline void test() {
	map<int, int> mp;
	mp.insert(pair<int, int>(1, 10));
	mp.insert(pair<int, int>(2, 20));
	mp.insert(pair<int, int>(3, 30));
	if (mp.empty()) {
		cout << "mp为空" << endl;
	}
	else {
		cout << "mp不为空" << endl;
		cout << "mp的大小为：" << mp.size() << endl;
	}
}


//交换
static inline void test02() {
	map<int, int> mp;
	mp.insert(pair<int, int>(1, 10));
	mp.insert(pair<int, int>(2, 20));
	mp.insert(pair<int, int>(3, 30));
	map<int, int> mp2;
	mp2.insert(pair<int, int>(4, 10));
	mp2.insert(pair<int, int>(5, 20));
	mp2.insert(pair<int, int>(6, 30));
	cout << "交换前的打印 ------" << endl;
	printMap(mp);
	printMap(mp2);
	cout << "交换后的打印 ------" << endl;
	mp2.swap(mp);
	printMap(mp);
	printMap(mp2);
}
int main()
{
	test02();
	system("pause");
	return 0;
}

233_67map容器-插入和删除

功能描述：

map容器进行插入数据和删除数据

函数原型：

insert(elem);                //在容器中插入元素
clear();                     //清除所有元素
erase(pos);                  //删除pos迭代器所指的元素，返回下一个元素的迭代器
erase(beg,end);              //删除区间[beg,end)的所有元素，返回下一个元素的迭代器
erase(key);                  //删除容器中值为key的元素

#include<iostream>
#include<string>
#include<map>
using namespace std;
//map容器   插入和删除
static inline void printMap(const  map<int, int>& mp) {
	for (map<int, int>::const_iterator it = mp.begin(); it != mp.end(); ++it) {
		cout << "key = " << it->first << "value = " << it->second << endl;
	}
	cout << endl;
}

static inline void test() {
	map<int, int> mp;
	//插入
	//第一种
	mp.insert(pair<int, int>(1, 10));
	//第二种
	mp.insert(make_pair(2, 20));
	//第三种
	mp.insert(map<int, int>::value_type(3, 30));
	//第四种
	//[]不建议插入，用途 可以利用key访问到value
	mp[4] = 40;
	cout << mp[2] << endl;
	printMap(mp);
	//删除
	mp.erase(mp.begin());
	printMap(mp);

	mp.erase(3);  //按照key删除
	printMap(mp);
}
int main()
{
	test();
	system("pause");
	return 0;
}

234_68map容器中-查找和统计

功能描述：

对map容器进行查找数据以及统计数据

函数原型：

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

#include<iostream>
#include<string>
#include<map>
using namespace std;
//map容器中的查找和统计

static inline void test() {
	//查找
	map<int, int> mp;
	mp.insert(make_pair(1, 20));
	mp.insert(pair<int, int>(2, 30));
	mp.insert(map<int, int>::value_type(3, 40));
	mp.insert(map<int, int>::value_type(3, 50));
	mp[4] = 50;
	map<int, int>::iterator pos = mp.find(3);
	auto pos1 =mp.find(4);
	if (pos != mp.end()) {
		cout << "查到了元素key = " << (*pos).first << "\t value = " << pos->second << endl;
	}
	else {
		cout << "为找到元素" << endl;
	}
	//统计
	//map不允许插入重复key 元素，count统计而言，结果要么是0要么是1
	//multimap的count统计可能大于1
	int num = mp.count(3);
	cout << "num = " << num << endl;
}

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

总结：

查找 —find（返回的是迭代器）
统计 —count(对于map，结果为0或结果为1)

235_69map容器-排序

学习目标：

map容器默认排序规则为按照key值进行从小到大排序，掌握如何改变排序规则

主要技术点：

利用仿函数，可以改变排序规则

#include<iostream>
#include<string>
#include<map>
using namespace std;
//map容器   排序
class myCompare {
public:
	bool operator()(int a, int b)const{
		return a > b;
	}
};
static  inline void printMap(const map<int, int,myCompare>& mp) {
	for (map<int, int,myCompare>::const_iterator it = mp.begin(); it != mp.end(); ++it) {
		cout << "Key = " << it->first << "\tValue = " << it->second << endl;
	}
	cout << endl;
}
static inline void test() {
	map<int, int,myCompare>mp;
	for (int i = 1; i < 5; i++) {
		mp.insert(make_pair(i, i * 10));
		mp.insert(pair<int, int>(6 * i, i * 20));
	}
	printMap(mp);
}
int main()
{
	test();
	system("pause");
	return 0;
}

236_70STL案例2-员工分组

案例描述：

公司今天招聘了10个员工，10名员工进入公司之后，需要指派员工在那个部门工作
员工信息有：姓名工资组成；部门分为：策划、美术、研发
随机给10名员工分配部门和工资
通过multimap进行信息的插入 key(部门编号) value(员工)
分部门显示员工信息

实现步骤：
1、创建10名员工，放到vector中
2、遍历vector容器，取出每个员工，进行随机分组
3、分组后，将员工部门编号作为key，具体员工工作为value，放符到multimap容器中
4、分部门显示员工信息

#include<iostream>
#include<string>
#include<vector>
#include<map>
#include<ctime>
using namespace std;
#define CEHUA 0
#define MEISHU 1
#define YANFA 2
class Worker {
public:
	string m_Name;
	int m_Salary;

};
static inline void createWorker(vector<Worker>& v) {
	string nameSeed = "ABCDEFGHIJ";
	for (int i = 0; i < 10; i++) {
		Worker worker;
		worker.m_Name = "员工";
		worker.m_Name += nameSeed[i];
		worker.m_Salary = rand() % 10000 + 10000; //10000 ~19999
		//将员工放入到容器中
		v.push_back(worker);
	}
}

//员工的分组
static inline void setGroup(vector<Worker>& v, multimap<int, Worker>& m) {
	for (vector<Worker>::iterator it = v.begin(); it != v.end(); ++it) {
		//产生随机部门编号
		int deptId = rand() % 3;  //0 1 2
		//将员工插入到分组中
		m.insert(make_pair(deptId, *it));
	}
}

static inline void showWorkerByGourp(multimap<int, Worker>& m) {
	//0 A B C 1 D E 2 F G ...
	cout << "策划部门：" << endl;
	multimap<int,Worker>::iterator pos =m.find(CEHUA);
	int count = m.count(CEHUA);
	int index = 0;
	for (; pos != m.end() && index < count; pos++, index++) {
		cout << "姓名：" << pos->second.m_Name << "工资：" << pos->second.m_Salary << endl;
	}
	cout << "----------------------------" << endl;
	cout << "美术部门：" << endl;
	pos = m.find(MEISHU);
    count = m.count(MEISHU);
	index = 0;
	for (; pos != m.end() && index < count; pos++, index++) {
		cout << "姓名：" << pos->second.m_Name << "工资：" << pos->second.m_Salary << endl;
	}
	cout << "----------------------------" << endl;
	cout << "研发部门：" << endl;
	pos = m.find(YANFA);
	count = m.count(YANFA);
	index = 0;
	for (; pos != m.end() && index < count; pos++, index++) {
		cout << "姓名：" << pos->second.m_Name << "工资：" << pos->second.m_Salary << endl;
	}
}

int main()
{
	srand((unsigned int)time(nullptr));
	//1、创建员工
	vector<Worker> vWorker;
	createWorker(vWorker);
	//2、员工分组
	multimap<int, Worker> mWorker;
	setGroup(vWorker, mWorker);
	//3、分组显示员工
	showWorkerByGourp(mWorker);
	//测试
	/*for (vector<Worker>::iterator it = vWorker.begin(); it != vWorker.end(); ++it) {
		cout << "姓名： " << it->m_Name << "\t工资：" << it->m_Salary << endl;
	}*/
	system("pause");
	return 0;
}

237_71函数对象基本使用

概念：

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

本质：
函数对象（仿函数）是一个类，不是一个函数
函数对象使用
特点：

函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值
函数对象超出普通函数的概念，函数对象可以有自己的状态
函数对象可以作为参数传递

#include<iostream>
#include<string>
using namespace std;
//函数对象(仿函数)
/*
*/
class MyAdd {
public:
	int operator()(int v1, int v2) {
		return v1 + v2;
	}
};
//1、函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值
static inline void test() {
	MyAdd myAdd;
	cout << myAdd(10, 10) << endl;
}
//2、函数对象超出普通函数的概念，函数对象可以有自己的状态
class MyPrint {
public:
	MyPrint() {
		this->count = 0;
	}
	void operator()(string test) {
		cout << test << endl;
		this->count++;
	}
	int  count;   //内部自己的初始值
};
static inline void test01() {
	MyPrint myPrint;
	myPrint("Hello World");
	myPrint("Hello World");
	myPrint("Hello World");
	cout << "myPrint调用次数为：" << myPrint.count << endl;
}

//3、函数对象可以作为参数传递
static inline void doPrint(MyPrint& mp, string test) {
	mp(test);
}
static inline void test03() {
	MyPrint myPrint;
	doPrint(myPrint, "Hello C++");
}
int main()
{
	test03();
	system("pause");
	return 0;
}

238_72谓词-一元谓词

概念：

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

#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;
//仿函数  返回值类型是bool数据类型，称为谓词
//一元谓词
class GreaterFive {
public:
	bool operator()(int val) {
		return val > 5;
	}
};

static inline void test01() {
	vector<int> v;
	for (int i = 0; i < 10; i++) {
		v.push_back(i);
	}
	//查找容器中，有没有大于5的数字
	//GreaterFive()匿名的函数对象
	vector<int>::iterator it =find_if(v.begin(), v.end(), GreaterFive());
	if (it == v.end()) {
		cout << "未找到" << endl;
	}
	else {
		cout << "找到了大于5的数字为：" << *it << endl;
	}
}
int main()
{
	test01();
	system("pause");
	return 0;
}

239_73谓词-二元谓词

概念：

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

#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;
//二元谓词
class myCompare {
public:
	bool operator()(int val1, int val2) {
		return  val1 > val2;
	}
};
static inline void printVector(const vector<int>& v) {
	for (vector<int>::const_iterator it = v.begin(); it != v.end(); ++it) {
		cout << *it << " ";
	}
	cout << endl;
}
static inline void test01() {
	vector<int> v;
	for (int i = 1; i < 6; i++) {
		v.push_back(i * 10);
		v.push_back(i * 2);
	}
	sort(v.begin(), v.end());
	printVector(v);
	cout << endl;
	//使用函数对象改变算法策略，变为排序规则为从大到小
	sort(v.begin(), v.end(), myCompare());
	printVector(v);
}
int main()
{
	test01();
	system("pause");
	return 0;
}

240_74内建函数对象-算术仿函数

内建函数对象的意义
概念：

STL内建了一些函数对象

分类：

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

用法：

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

算法仿函数
功能描述：

实现四则运算
其中negate是一元运算，其他都是二元运算

仿函数原型：

template<class T> T plus<T>      //加法仿函数
template<class T> T minus<T>     //减法仿函数
template<class T> T multiplies<T>//乘法仿函数
template<class T> T divides<T>   //除法仿函数
template<class T> T modulus<T>   //取模仿函数
template<class T> T negate<T>    //取反仿函数

#include<iostream>
#include<string>
#include<functional>
using namespace std;
//内建函数对象， 算法仿函数

//negate 一元仿函数   取反仿函数
static inline void test() {
	negate<int> n;
	cout << n(50) << endl;
}
//plus 二元仿函数   加法
static inline void test02() {
	plus<int> p;
	cout << p(10, 20) << endl;
}
int main()
{
	test02();
	system("pause");
	return 0;
}

241_75内建函数对象-关系仿函数

功能描述：

实现关系对比

函数原型：

template<class T> bool equal_to<T>      //等于
template<class T> bool not_equal_to<T>  //不等于
template<class T> bool greater<T>       //大于
template<class T> bool greater_equal<T> //大于等于
template<class T> bool less<T>          //小于
template<class T> bool less_equal<T>    //小于等于

#include<iostream>
#include<string>
#include<vector>
#include<functional>
#include<algorithm>
using namespace std;
//内建函数对象  关系仿函数
//大于  greater
class MyCompare {
public:
	bool operator()(int v1, int v2) {
		return v1 > v2;
	}
};
static inline void printVector(const vector<int>& v) {
	for (vector<int>::const_iterator it = v.begin(); it != v.end(); ++it) {
		cout << *it << " ";
	}
	cout << endl;
}
static inline void test() {
	vector<int> v;
	for (int i = 1; i < 6; i++) {
		v.push_back(i * 10);
	}
	printVector(v);
	//降序
	//sort(v.begin(),v.end(), MyCompare());
	//greater<int>()  内建函数对象
	sort(v.begin(), v.end(), greater<int>());
	printVector(v);
}
int main()
{
	test();
	system("pause");
	return 0;
}

总结：关系仿函数中最常用的就是greater<>大于

242_76内建函数对象-逻辑仿函数

功能描述：

实现逻辑运算

函数原型：

template<class T> bool logical_and<T>      //逻辑与
template<class T> bool logical_or<T>       //逻辑或
template<class T> bool logical_not<T>      //逻辑非

#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
#include<functional>
using namespace std;
//内建函数对象_逻辑仿函数
//逻辑非  logical_not

static inline void printVector(const vector<bool>& v) {
	for (vector<bool>::const_iterator it = v.begin(); it != v.end(); ++it) {
		cout << *it << " ";
	}
	cout << endl;
}
static inline void test() {
	vector<bool> v;
	v.push_back(true);
	v.push_back(false);
	v.push_back(true);
	v.push_back(false);
	printVector(v);
	//利用逻辑非，将容器v搬运到 容器v2中，并执行取反的操作
	vector<bool>v2;
	v2.resize(v.size());
	transform(v.begin(), v.end(), v2.begin(),logical_not<bool>());
	printVector(v2);
}

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

243_77常用遍历算法-for_each

概述：

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

常用遍历算法

for_each      //遍历容器
transform     //搬运容器到另一个容器

for_earch

实现遍历容器

函数原型：

for_each(iterator beg,iterator end, _func);
//遍历算法  遍历容器元素
//beg 开始迭代
//end 结束迭代
//_func函数或者函数对象

#include<iostream>
#include<string>
#include<algorithm>
#include<vector>
using namespace std;
//常用的遍历算法 for_each

//普通函数
static inline void print01(int val) {
	cout << val << " ";
}
//仿函数
class print02 {
public:
	void operator()(int val) {
		cout << val << " ";
	}
};
static inline void test() {
	vector<int> v;
	for (int i = 0; i < 10; i++) {
		v.push_back(i);
	}
	for_each(v.begin(), v.end(), print01);
	cout << endl;
	for_each(v.begin(), v.end(), print02());
	cout << endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

244_78常用遍历算法-transform

功能描述：
搬运容器到另一个容器中
函数原型：

transform(iterator beg1,iterator end1,iterator beg2,_func);
//beg1  源容器开始迭代器
//end1  源容器结束迭代器
//beg2  目标容器开始迭代器
//_func 函数或者函数对象

#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;
//常用遍历算法  transform
class Tranform {
public:
	int operator()(int v) {
		return v +100;
	}
};

class MyPrint {
public:
	void operator()(int val) {
		cout << val << " ";
	}
};
static inline void test() {
	vector<int> v;
	for (int i = 0; i < 10; i++) {
		v.push_back(i);
	}
	vector<int>vTarget;        //目标容器
	vTarget.resize(v.size());  //目标容器，需要提前开辟空间
	transform(v.begin(), v.end(), vTarget.begin(), Tranform());
	for_each(vTarget.begin(), vTarget.end(), MyPrint());
	cout << endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

245_79常用遍历算法-find

学习目标：

掌握常用的查找算法

算法简介：

find             //查找元素
find_if          //按条件查找元素
adjacent_find    //查找相邻重复元素
binary_search    //二分查找法
count            //统计元素个数
count_if         //按条件统计元素个数

find
功能描述：

查找指定元素，找到返回指定元素的迭代器，找不到返回结束迭代器end()

函数原型：

find(iterator beg,iterator end, value);
//按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置
//beg开始迭代器
//end结束迭代器
//value查找的元素

#include<iostream>
#include<vector>
#include<string>
using namespace std;
//常用查找算法

//find
//查找  内置数据类型
static inline void test() {
	vector<int> v;
	for (int i = 0; i < 10; i++) {
		v.push_back(i);
	}
	//查找  容器中 是否有5这个元素
	vector<int>::iterator it = find(v.begin(), v.end(), 5);
	if (it == v.end()) {
		cout << "没有找到！" << endl;
	}
	else {
		cout << "找到了该数字为： " << *it << endl;
	}
}

class Person {
public:
	Person(string name, int age) :m_Name(name), m_Age(age) {

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

//查找  自定义类型数据
static inline void test01() {
	vector<Person> v;
	//创建数据
	Person p1("aaa", 10);
	Person p2("bbb", 20);
	Person p3("ccc", 30);
	Person p4("ddd", 40);
	Person pp("bbb", 20);
	//放入到容器
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);
	vector<Person>::iterator it = find(v.begin(), v.end(), pp);
	if (it == v.end()) {
		cout << "没有找到" << endl;
	}
	else {
		cout << "找到了姓名是：" << it->m_Name << "\t年龄为：" << it->m_Age << endl;
	}
}
int main()
{
	test01();
	system("pause");
	return 0;
}

总结：利用find可以在容器中找指定的元素，返回值是迭代器

246_80常用查找算法find_if

功能描述：

按条件查找元素

函数原型：

find_if(iterator beg,iterator end,_Pred);
//按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置
//beg开始迭代器
//end结束迭代器
//_Pred函数或者谓词（返回bool类型的仿函数）

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

//常用的查找算法 find_if

//1、查找内置类数据类型
class GreateFive {
public:
	bool operator()(int val) {
		return val > 5;
	}
};
static inline void test() {
	vector<int> v;
	for (int i = 0; i < 10; i++) {
		v.push_back(i);
	}
	vector<int>::iterator it = find_if(v.begin(), v.end(), GreateFive());
	if (it == v.end()) {
		cout << "找到元素：" << endl;
	}
	else {
		cout << "找到大于5的数字为：" << *it << endl;
	}
}

//2、查找自定义数据类型
class Person {
public:
	Person(string name, int age):m_Name(name),m_Age(age) {

	}
	string m_Name;
	int m_Age;
};
class Greate20 {
public:
	bool operator()(Person& p) {
		return p.m_Age > 20;
	}
};

static inline void test02() {
	vector<Person> v;
	//创建数据
	Person p1("aaa", 10);
	Person p2("bbb", 20);
	Person p3("ccc", 30);
	Person p4("ddd", 40);
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);
	//找年龄大于20的人
	vector<Person>::iterator it = find_if(v.begin(), v.end(), Greate20());
	if (it == v.end()) {
		cout << "没有找到" << endl;
	}
	else {
		cout << "找到姓名：" << it->m_Name << "\t年龄：" << it->m_Age << endl;
	}
}
int main()
{
	test02();
	system("pause");
	return 0;
}

247_81常用查找算法-adjacent_find

功能描述：

查找相邻重复元素

函数原型：

adjacent_find(iterator beg,iterator end);
//查找相邻重复元素，返回相邻元素的第一个位置的迭代器
//beg开始迭代器
//end结束迭代器

#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
//常用查找算法 adjacent_find

static inline void test() {
	vector<int>v;
	v.push_back(0);
	v.push_back(2);
	v.push_back(0);
	v.push_back(3);
	v.push_back(1);
	v.push_back(4);
	v.push_back(3);
	v.push_back(3);
	vector<int>::iterator pos = adjacent_find(v.begin(), v.end());
	if (pos == v.end()) {
		cout << "未找到相邻重复元素" << endl;
	}
	else {
		cout << "找到了相邻重复元素为： " << *pos << endl;
	}
}

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

总结：面试题中如果出现了查找相邻重复元素，记得用STL中的adjacent_find算法

248_82常用查找算法-binary_search

功能描述：

查找指定元素是否存在

函数原型：

bool binary_serch(iterator beg, iterator end,value);
//查找指定的元素，查到返回true，否则返回false
//注意：在无序序列中不可用
//beg开始迭代器
//end结束迭代器
//value查找的元素

#include<iostream>
#include<vector>
#include<algorithm>
#include<string>
using namespace std;
//常用的查找算法  binary_search

static inline void test() {
	vector<int> v;
	for (int i = 0; i < 10; i++) {
		v.push_back(i);
	}
	//查找容器中是否有9  元素
	//注意：容器中必须是有序的序列
	bool ret = binary_search(v.begin(), v.end(), 9);
	if (ret) {
		cout << "找到了元素" << endl;
	}
	else {
		cout << "未找到元素：" << endl;
	}
}
int main()
{
	test();
	system("pause");
	return 0;
}

249_83常用查找算法-count

功能描述：

统计元素的个数

函数原型：

count(iterator beg, iterator end, value);
//统计元素出现的次数
//beg开始迭代器
//end结束迭代器
//value统计的元素

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

//常用的查找算法_count
//1、统计内置数据类型
static inline void test() {
	vector<int> v;
	for (int i = 1; i < 5; i++) {
		v.push_back(i * 1);
		v.push_back(i * 2);
	}
	int num  =  count(v.begin(), v.end(), 2);
	cout << "2的元素个数为：" << num << endl;
}
//2、统计自定义的数据类型
class Person {
public:
	Person(string name, int age) :m_Name(name), m_Age(age) {

	}
	bool operator==(const Person& p) {
		if (this->m_Age == p.m_Age) {
			return true;
		}
		else {
			return false;
		}
	}
	string m_Name;
	int m_Age;
};

static void test01() {
	vector<Person> v;
	Person p1("刘备", 35);
	Person p2("关羽", 29);
	Person p3("张飞", 27);
	Person p4("赵云", 28);
	Person p5("曹操", 35);
	//将人员插入到容器中
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);
	v.push_back(p5);
	Person p("诸葛亮", 35);
	
	int num = count(v.begin(), v.end(), p);
	cout << "和诸葛亮同岁数的人员个数为：" << num << endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

总结：统计自定义数据类型时候，需要配合重载operator==

250_84常用查找算法-count_if

功能描述：

按条件统计元素个数

函数原型：

count_if(iterator beg, iterator end, _Pred);
//按条件统计元素出现次数
//beg开始迭代器
//end结束迭代器
//_Pred谓词

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

//常用的查找算法   count_if
//统计内置的数据类型
class Greater20 {
public:
	bool operator()(int val) {
		return val > 20;
	}
};
static inline void test() {
	vector<int> v;
	v.push_back(10);
	v.push_back(30);
	v.push_back(40);
	v.push_back(30);
	v.push_back(20);

	int num = count_if(v.begin(), v.end(), Greater20());
	cout << "大于20的元素个数为：" << num << endl;

}
//统计自定义的数据类型
class Person {
public:
	Person(string name, int age) :m_Name(name),m_Age(age){

	}
	string m_Name;
	int m_Age;
};
class AgeGreater20 {
public:
	bool operator()(const Person &p){
		return p.m_Age > 20;
	}
};
static inline void test01() {
	vector<Person> v;
	Person p1("刘备", 35);
	Person p2("关羽", 29);
	Person p3("张飞", 27);
	Person p4("赵云", 28);
	Person p5("曹操", 35);
	v.push_back(p1), v.push_back(p2), v.push_back(p3), v.push_back(p4), v.push_back(p5);
	//统计  年龄大于28
	int num = count_if(v.begin(), v.end(), AgeGreater20());
	cout << "大于20岁的人员个数为：" << num << endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

251_85常用的排序算法

学习目标：

掌握常用的排序算法

算法简介：

sort              //对容器内元素进行排序
random_shuffle    //洗牌   指定范围内的元素随机调整次序
merge             //容器元素合并，并存储到另一个容器中
reverse           //反转指定范围的元素

sort
功能描述：

对容器内元素进行排序

函数原型：

sort(iterator beg,iterator end,_Pred);
//按值查找元素，找到返回只当位置迭代器，找不到返回结束迭代器位置
//beg  开始迭代
//end 结束迭代器
//_Pred谓词

#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<functional>
using namespace std;
static inline void printVector(const vector<int>& v) {
	for (vector<int>::const_iterator it = v.begin(); it != v.end(); ++it) {
		cout << *it << " ";
	}
	cout << endl;
}

static void myPrint(int val) {
	cout << val << " ";
}
class myPrint01 {
public:
	 void operator()(const int val){
		cout << val << " ";
	}
};
class myCompare {
public:
	bool operator()(int v1, int v2) {
		return v1 > v2;
	}
};

//常用排序算法 sort
static inline void test() {
	vector<int> v;
	for (int i = 1; i < 5; i++) {
		v.push_back(i * 5);
		v.push_back(i * 2);
		v.push_back(i * 8);
	}
	cout << "排序前：" << endl;
	printVector(v);
	sort(v.begin(), v.end());
	cout << "排序后：" << endl;
	printVector(v); 
	cout << "--------------------" << endl;
	for_each(v.begin(), v.end(), myPrint);
	cout << endl;
	cout << "**********************" << endl;
	for_each(v.begin(), v.end(), myPrint01());
	cout << endl;
	//改变为   降序
	cout << "^^^^^^^^^^^^^^^^^^^^^^^" << endl;
	sort(v.begin(), v.end(), greater<int>());
	//sort(v.begin(), v.end(), myCompare());
	for_each(v.begin(), v.end(), myPrint01());
	cout << endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

252_86常用排序算法-random_shuffle

功能描述：

洗牌指定范围内的元素随机调整次序

函数原型：

random_shuffle(iterator beg, iterator end);
//指定范围内的元素随机调整次序
//beg开始迭代器
//end结束迭代器

#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<ctime>
using namespace std;
//常用的排序算法   random_shuffle
class myPrint {
public:
	void operator()(const int val) {
		cout << val << " ";
	}
};
static inline void test() {
	srand((unsigned int)time(nullptr));
	vector<int> v;
	for (int i = 0; i < 10; i++) {
		v.push_back(i);
	}
	for_each(v.begin(), v.end(), myPrint());
	cout << endl;
	//利用洗牌算法  打乱顺序
	random_shuffle(v.begin(), v.end());
	for_each(v.begin(), v.end(), myPrint());
	cout << endl;

}

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

253_87常用排序算法-merge

功能描述：

两个容器元素合并，并存储到另一个容器中

函数原型：

merge(iterator beg1,iterator end1,iterator beg2,iterator end2,iterator dest);
//容器元素合并，并存储到另一个容器中
//注意：两个容器必须是有序的
//beg1  容器1开始迭代器
//end1  容器1结束迭代器
//beg2  容器2开始迭代器
//end2  容器2结束迭代器
//dest  目标容器开始迭代器

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

//常用的排序算法merge
class myPrint {
public:
	void operator()(int val) {
		cout << val << " ";
	}
};
static inline void test() {
	vector<int> v1, v2;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);
		v2.push_back(i + 1);
	}
	//目标容器
	vector<int>vTarget;
	vTarget.resize(v1.size() + v2.size());
	merge(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
	for_each (vTarget.begin(), vTarget.end(), myPrint());
	cout << endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

254_88常用排序算法-reverse

功能描述：

将容器内元素进行反转

函数原型：

reverse(iterator beg, iterator end);
//反转指定范围的元素
//beg开始迭代器
//end结束迭代器

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

//常用排序算法  reverse
class myPrint {
public:
	void operator()(int val) {
		cout << val << " ";
	}
};
static inline void test() {
	vector<int> v;
	for (int i = 0; i < 10; i++) {
		v.push_back(i);
	}
	cout << "反转前： " << endl;
	for_each(v.begin(), v.end(), myPrint());
	cout << "反转后： " << endl;
    reverse(v.begin(),v.end());
	for_each(v.begin(), v.end(), myPrint());
	cout << endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

255_89常用拷贝和替换算法-copy

学习目标：

掌握常用的拷贝和替算法

算法简介：

copy          //容器内指定范围的元素拷贝到另一个容器中
replace       //将容器内指定范围的旧元素修改为新元素
replace_if    //容器内指定范围满足条件的元素替换为新元素
swap          //互换两个容器的元素

copy
功能描述：

容器内指定范围的元素拷贝到另一个容器中

函数原型：

copy(iterator beg,iterator end,iterator dest);

#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
//常用的拷贝和替换算法copy
class myPrint {
public:
	void operator()(int val) {
		cout << val << " ";
	}
};
static inline void test() {
	vector<int> v1,v2;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);
	}
	v2.resize(v1.size());
	copy(v1.begin(), v1.end(), v2.begin());
	for_each(v2.begin(), v2.end(), myPrint());
	cout << endl;
}

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

256_90常用拷贝和替换算法-replace

功能描述：

将容器内指定范围的旧元素修改为新元素

函数原型：

replace(iterator beg, iterator end, oldvalue, newvalue);
//将区间内旧元素替换成新元素

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

//常用拷贝和替换算法  replace
class myPrint {
public:
	void operator()(int val) {
		cout << val << " ";
	}
};

static inline void test() {
	vector<int>v;
	for (int i = 0; i < 6; i++) {
		v.push_back(i);
		v.push_back(i*2);
		v.push_back(i*3);
	}
	cout << "替换前：" << endl;
	for_each(v.begin(), v.end(), myPrint());
	cout << endl;
	replace(v.begin(), v.end(), 0, 2000);
	cout << "替换后：" << endl;
	for_each(v.begin(), v.end(), myPrint());
	cout << endl;
}

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

总结：replace 会替换区间内满足条件的元素

257_91常用拷贝和替换算法-repalce_if

功能描述：

将区间内满足条件的元素，替换成指定元素

函数原型：

replace_if(iterator beg,iterator end,_Pred,newvalue);

#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
//常用拷贝和替换算法  replace_if
class Greater5 {
public:
	bool operator()(int val) {
		return  val >= 5;
	}
};
class myPrint {
public:
	void operator()(int val) {
		cout << val << " ";
	}
};
static void test() {
	vector<int>v;
	for (int i = 1; i < 6; i++) {
		v.push_back(i);
		v.push_back(i * 2);
		v.push_back(i + 2);
	}
	for_each(v.begin(), v.end(), myPrint());
	cout << endl;
	//将大于等于5的 替换成3000
	cout << "替换后：" << endl;
	replace_if(v.begin(), v.end(), Greater5(), 3000);
	for_each(v.begin(), v.end(), myPrint());
	cout << endl;
}

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

总结：replace_if按条件查找，可以利用仿函数灵活筛选满足的条件

258_92常用拷贝和替换算法-swap

功能描述：
函数原型：

swap(container c1,containerc2);

#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
//常用拷贝和替换算法swap
//打印输出1  ---迭代器
static inline void printVector1(const vector<int>& v) {
	for (vector<int>::const_iterator it = v.begin(); it != v.end(); ++it) {
		cout << *it << " ";
	}
	cout << endl;
}
//打印输出2  ---[ ]
static inline void printVector2(const vector<int>& v) {
	for (int i = 0; i < v.size(); i++) {
		cout << v[i] << " ";
	}
	cout << endl;
}

//打印输出3 --at
static inline void printVector3(const vector<int>& v) {
	for(int i = 0;i < v.size();i++){
		cout << v.at(i) << " ";
	}
	cout << endl;
}

class myPrint {
public:
	inline void operator()(int val) {
		cout << val << " ";
	}
};

//打印输出4 --for_each()
static inline void printVector4(const vector<int>& v) {
	for_each(v.begin(), v.end(), myPrint());
	cout << endl;
}
static inline void test() {
	vector<int> v1,v2;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);
		v2.push_back(i + 100);
	}
	cout << "交换前：" << endl;
	printVector1(v1);
	printVector2(v2);
	cout << "_-----------------------" << endl;
	cout << "交换后：" << endl;
	swap(v1, v2);
	printVector2(v1);
	printVector3(v2);
}

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

打印输出的四种方法（序列式容器）

迭代器方法

//打印输出1  ---迭代器
static inline void printVector1(const vector<int>& v) {
	for (vector<int>::const_iterator it = v.begin(); it != v.end(); ++it) {
		cout << *it << " ";
	}
	cout << endl;
}

2.数组【】

//打印输出2  ---[ ]
static inline void printVector2(const vector<int>& v) {
	for (int i = 0; i < v.size(); i++) {
		cout << v[i] << " ";
	}
	cout << endl;
}

at()

//打印输出3 --at
static inline void printVector3(const vector<int>& v) {
	for(int i = 0;i < v.size();i++){
		cout << v.at(i) << " ";
	}
	cout << endl;
}

4.for_each()

class myPrint {
public:
	inline void operator()(int val) {
		cout << val << " ";
	}
};
//打印输出4 --for_each()
static inline void printVector4(const vector<int>& v) {
	for_each(v.begin(), v.end(), myPrint());
	cout << endl;
}

260_94常用算术生成算法-accumulate

学习目标：
注意：

算术生成算法属于小型算法，使用时包含的头文件为#include< numeric>

算法简介：

accumulate         //计算容器元素累计总和
fill               //向容器中添加元素

accumulate
功能描述

计算容器元素累计总和

函数原型：

accumulate(iterator beg,iterator end,value);
//计算容器元素累计总和
//beg开始迭代器
//end结束迭代器
//value起始值

#include<iostream>
#include<vector>
#include<string>
#include<numeric>
using namespace std;
//常用算术生成算法
static inline void test() {
	vector<int> v;
	for (int i = 0; i <= 100; i++) {
		v.push_back(i);
	}
	//参数3  起始累加值
	int total = accumulate(v.begin(), v.end(), 1000);
	cout << "total = " << total << endl;
}

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

260_94常用算术生成算法-fill

功能描述：

向容器中填充指定的元素

函数原型：

fill(iterator beg,iterator end, value);
//向容器中填充元素
//beg开始迭代器
//end结束迭代器
//value 填充的值

#include<iostream>
#include<vector>
#include<string>
#include<numeric>
#include<algorithm>
using namespace std;
//常用算术生成算法fill
class myPrint {
public:
	void operator()(int val) {
		cout << val << " ";
	}
};

static inline void test() {
	vector<int> v;
	//for (int i = 0; i < 10; i++) {
	//	v.push_back(i);
	//}
	v.resize(10);
	//后期重新填充
	fill(v.begin(), v.end(), 100);
	for_each(v.begin(), v.end(), myPrint());
	cout << endl;
}

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

261_95常用集合算法-set_intersection

学习目标：

掌握常用的集合算法

算法简介：

set_intersection     //求两个容器的交集
set_union            //求两个容器的并集
set_difference       //求两个容器的差集

功能描述：

求两个容器的交集

函数原型：

set_intersection(iterator beg1,iterator end1,iterator beg2,iterator end2,iteartor dest);
//求两个集合的交集

#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
//常用的集合算法   set_intersection
class myPrint {
public:
	void operator()(int val) {
		cout << val << " ";
	}
};

static inline void test() {
	vector<int>v1, v2;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);
		v2.push_back(i + 5);
	}
	for_each(v1.begin(), v1.end(), myPrint());
	cout << endl;
	for_each(v2.begin(), v2.end(), myPrint());
	cout << endl;
	vector<int >vTarget;
	vTarget.resize(min(v1.size(), v2.size()));

	//获取交集
	vector<int>::iterator itEnd = set_intersection(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
	for_each(vTarget.begin(), itEnd, myPrint());
	cout << endl;
}

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

总结：

求交集的两个集合必须得有序序列
目标容器开辟空间需要从两个容器中取小值
set_intersection返回值既是交集中最后一个元素的位置

262_96常用集合算法-set_union

功能描述：

求两个集合的并集

函数原型：

set_union(iterator beg1,iterator end1,iterator beg2,iterator end2,iterator dest);

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


//常用的集合算法   set_union
void myPrint(int val) {
	cout << val << " ";
}
static inline void test() {
	vector<int> v1, v2;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);
		v2.push_back(i + 5);
	}
	vector<int>vTarget;
	//目标容器提前开辟空间
	vTarget.resize(v1.size() + v2.size());
	vector<int>::iterator itEnd = set_union(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
	for_each(vTarget.begin(), itEnd, myPrint);
	cout << endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

总结：

求并集的两个集合必须得有序
目标容器开辟空间需要两个容器相加
set_union返回值既是并集中最后一个元素的位置

263_93常用集合算法-set_difference

set_difference(iterator beg1,iterator end1,iteraotr beg2,iterator end2,iterator dest);

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

class myPrint {
public:
	void operator()(int val) {
		cout << val << " ";
	}
};
static inline void test() {
	vector<int> v1, v2;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);
		v2.push_back(i + 5);
	}
	vector<int>vTarget;
	vTarget.resize(max(v1.size(), v2.size()));
	vector<int>::iterator itEnd = set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
	for_each(vTarget.begin(), itEnd, myPrint());
	cout << endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

总结：

求差集的两个集合必须得有序序列
目标容器开辟空间需要从两个容器中取较大值
set_difference返回值既是差集中最后一个元素的位置

yangyang_z

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
C++提高编程篇

C++入门基础002第一个C++程序C++书写helloworld#include<iostream>#include<string>using namespace std;int main(){ string str = { "Hello Word" }; cout << str << endl; system("pause"); return 0;}003程序的注释-单行注释和多行注释//单行注释/*多行注释，注意多行注释
复制链接

扫一扫

专栏目录