c++提高编程

文章目录

• STL
• • 1.模板
  • • 1.1模板的概念
    • 1.2 函数模板
    • • 1.2.1 函数模板语法
      • 1.2.2函数模板注意事项
      • 1.2.3 函数模板案例
      • 1.2.4 普通函数与函数模板的区别
      • 1.2.5 普通函数和函数模板的调用规则
      • 1.2.6 模板的局限性
    • 1.3 类模板
    • • 1.3.1 类模板语法
      • 1.3.2 类模板和函数模板区别
      • 1.3.3 类模板中成员函数创建时机
      • 1.3.4 类模板对象做函数参数
    • 3.3 deque容器
    • • 3.3.2 deque构造函数
      • 3.3.3 deque容器赋值
      • 3.3.4 deque容器大小操作
      • 3.3..5 deque插入和删除
      • 3.3.6 deque数据存取
      • 3.3.7 deque排序
    • 3.5 stack容器
    • • 3.5.1 stack基本概念
      • 3.5.2 stack常用接口
    • 3.6 queue容器
    • • 3.6.1 queue基本概念
    • 3.6.1queue 常用接口
    • 3.7 list容器
    • • 3.7.1 list容器基本概念
      • 3.7.2 list构造函数
      • 3.7.3 list赋值和交换
      • 3.7.4 list大小操作
      • 3.7.5 list插入和删除
      • 3.7.6 list数据存取
      • 3.7.7 list 反转和排序
    • 3.8 set/multset 容器
    • • 3.8.1 set基本概念
      • 3.8.2 set构造和赋值
      • 3.8.3 set大小和交换
      • 3.8.4 set插入和删除
      • 3.8.5 set查找和统计
      • 3.8.6 set和multset区别
      • 3.8.7 pair对组创建
      • 3.8.8 set容器排序
    • 3.9 map/multmap 容器
    • • 3.9.1 map基本概念
      • 3.9.2 map构造和赋值
      • 3.9.3 map大小和交换
      • 3.9.4 map插入和删除
      • 3.9.5 map查找和统计·
      • 3.9.6 map容器排序
    • 4 STL -函数对象
    • • 4.1 函数对象概念
      • 4.1.2 函数对象使用
    • 4.2 谓词
    • • 4.2.1 谓词基本概念
      • 4.2.3 二元谓词
    • 4.3 内建函数对象
    • • 4.3.1 内建函数对象意义
      • 4.3.2 算术仿函数
      • 4.3.3 关系仿函数
      • 4.3.4 逻辑仿函数
      • **功能描述：**
      • 4.3.3 关系仿函数
      • 4.3.4 逻辑仿函数
      • **功能描述：**

STL

本阶段主要针对C++泛型编程和STL技术做详细讲解，探讨C++更深层的使用

1.模板 1.1模板的概念

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

模板的特点：

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

1.2 函数模板

C++另一种编程思想称为 泛型编程 ， 主要利用的技术就是模板

C++提供两种模板机制：函数模板 和 类模板

1.2.1 函数模板语法

函数模板作用：

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

语法：

template
函数声明或定义

解释：

template — 声明创建模板

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

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

#include
using namespace std;

//函数模板
template   
void mySwap(T& a, T& b)
{
	T temp = a;
	a = b;
	b = temp;
}

void test()
{
	int a = 10, b = 20;
	double c = 3.14, d = 1.414;

	//自动判断数据类型
	//mySwap(a, b);
	
	//给定数据类型
	mySwap(a,b);
	mySwap(c, d);
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
	cout << "d = " << d << endl;
}

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

总结：

函数模板利用关键字template

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

模板的目的是为了提高代码复用性 ， 将类型参数化

1.2.2函数模板注意事项

注意事项：

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

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

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

1.2.3 函数模板案例

案例描述：

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

#include
using namespace std;

template
void myswitch(T &a, T& b)
{
	T temp = a;
	a = b;
	b = temp;
}

//通用数组排序 ，大到小 ，char ， int数组
template 
void mySort(T arr[], int len)
{
	for (int i = 0; i < len; i++)
	{
		int max = i;
		for (int j = i + 1; j < len; j++)
		{
			//认定的最大值 比 遍历出的数值小 ， 说明j下标的元素才是真正的最大值
			if (arr[max] < arr[j]) 
			{
				max = j;
			}		
		}
		if (max != i)
		{
			//交换max和i元素
			myswitch(arr[max], arr[i]);
		}
	}
}

void test()
{
	char charArr[] = "ahfoah";
	int len = sizeof(charArr) / sizeof(charArr[0]);
	mySort(charArr, len);
	for (int i = 0; i < len; i++)
	{
		cout << charArr[i] << endl;
	}

	int arr[] = { 1,234,31,342,12,3,4,14,1,45 };
	int len2 = sizeof(arr) / sizeof(arr[0]);
	mySort(arr, len2);

	for (int i = 0; i < len; i++)
	{
		cout <

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

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

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

#include 
using namespace std;

//普通函数和函数模板的区别
int myadd(int a, int b)    
{
	return a + b;
}

template
T myadd2(T a, T b)
{
	return a + b;
}

void test()
{
	int a = 10, b = 20;
	int c = myadd(a, b);
	cout << c << endl;

	double d = 3.14;
	cout << myadd(a, d) << endl;    //普通函数可以发生隐式转换  （默认将不同类型转换）

	cout << myadd2(a, b) << endl;
	//cout << myadd2(a, d) << endl;   利用自动类型推导，不会发生隐式类型转换
	cout << myadd2(a, d) << endl;     //利用自动类型推导，不会发生隐式类型转换


}

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

总结：建议使用显示指定类型的方法，调用函数模板，因为可以自己确定通用类型T

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

调用规则如下：

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

#include 
using namespace std;

void myPrint(int a, int b)
{
	cout << "普通函数的调用" << endl;
}

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

//3. 函数模板也可以发生重载
template        
void myPrint(T a, T b,T c)
{
	cout << "函数模板重载的调用" << endl;
}

void test()
{
	int a = 10, b = 20;
	//1. 如果函数模板和普通函数都可以实现，优先调用普通函数
	myPrint(a, b);  
	//2. 可以通过空模板参数列表来强制调用函数模板
	myPrint<>(a, b); 

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

int main()
{
	test();

	system("pause");
	return 0;
}

总结：既然提供了函数模板，最好不要提供普通函数，否则容易出现二义性

1.2.6 模板的局限性

局限性：

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

  例如：

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

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

再例如：

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

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

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

例如：

#include 
using namespace std;
#include 

//模板的局限性: 有些特定的数据类型，需要用具体化方式做特殊实现
class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}

	string m_Name;
	int m_Age;
};


bool myCompare(int a, int b)
{
	if (a == b)
	{
		return true;
	}
	else
	{
		return false;
	}
}

template
bool myCompare2(T& a, T &b)
{
	if (a == b)
	{
		return true;
	}
	else
	{
		return false;
	}
}

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

void test()
{
	int a = 10, b = 20;
	bool ret = myCompare(a, b);
	if (ret)
	{
		cout << "a == b" << endl;
	}
	else
	{
		cout << "a != b" << endl;
	}
}

void test2()
{
	Person p1("tom", 18);
	Person p2("tom", 18);
	//bool ret = myCompare(p1, p2);
	bool ret = myCompare2(p1, p2);    
	if (ret)
	{
		cout << "p1 == p2" << endl;
	}
	else
	{
		cout << "p1 != p2" << endl;
	}

}

int main()
{
	test();
	test2();

	system("pause");
	return 0;
}

总结：

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

1.3 类模板 1.3.1 类模板语法

类模板作用：

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

语法：

template
类    

解释：

template： 声明创建模板

class ：表明其后面的符号是一种数据类型

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

#include 
using namespace std;
#include 

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

	NameType m_Name;
	AgeType m_Age;

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

};

void test()
{
	Person p1("小林", 22);
	p1.show();
}

int main()
{
	test();

	system("pause");
	return 0;
}

总结：类模板和函数模板语法很相似，在声明模板template后面加类，此类称为类模板

1.3.2 类模板和函数模板区别

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

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

#include 
using namespace std;
#include 

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

	NameType m_Name;
	AgeType m_Age;

	void show()
	{
		cout << "name =" << this->m_Name << "    " << "age = " << this->m_Age << endl;
	}
};
//1.类模板没有自动类型推导使用方式
void test01()
{
	//Person p1("小董", 23); 无法自定类型推导
	Person p1("小董", 23);
	p1.show();
}

//2.类模板可以在模板参数列表中可以有默认参数
void test02()
{
	Person p2("小刘", 25);
	p2.show();
}

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

总结：

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

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

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

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

#include 
using namespace std;
#include 

//类模板中成员函数创建时机
//类模板中成员函数在调用时才去创建
class Person1
{
public:
	void showPerson1()
	{
		cout << "Person1 show" << endl;
	}
};

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

template
class MyClass
{
public:
	T obj;
	//类模板中的成员函数在调用时才创建
	void func1()
	{
		obj.showPerson1();
	}

	void func2()
	{
		obj.showPerson2();
	}
};

void test()
{
	MyClass myclass1;
	myclass1.func1();
	MyClass myclass2;
	myclass2.func2();

}

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

1.3.4 类模板对象做函数参数

学习目标：

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

一共有三种传入方式：

• 指定传入的类型 ----- 直接现实对象的数据类型
• 参数模块化 ----- 将对象中的参数变为模板进行传递
• 整个类模板化 ------- 将这个对象类型 模板化进行传递

3.3 deque容器

功能：

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

deque与vector区别：

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

3.3.2 deque构造函数

功能描述：

• deque容器构造

函数原型：

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

void test()
{
	//deque构造函数
	deque v;
	for (int i = 0; i < 5; i++)
	{
		v.push_back(i);//尾插
		v.push_front(i + 10);//前插
	}
	myPrint(v);

	dequev2(v);//拷贝构造
	myPrint(v2);

	dequev3(v.begin() +1, v.end());//区间构造
	myPrint(v3);

	dequev4(5, 6);//元素构造  5个6
	myPrint(v4);
}

3.3.3 deque容器赋值

功能描述：

• 给deque容器进行赋值

函数原型：

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

void test()
{
	//deque构造函数
	deque v1;
	for (int i = 0; i < 5; i++)
	{
		v1.push_back(i);//尾插
	}
	myPrint(v1);

	dequev2 = v1;//=赋值
	myPrint(v2);

	dequev3;
	v3.assign(v1.begin(), v1.end());
	myPrint(v3);

	dequev4;
	v4.assign(5, 6);
	myPrint(v4);
}

3.3.4 deque容器大小操作

功能描述：

• 对deque容器的大小进行操作

函数原型：

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

void test()
{
	//deque构造函数
	deque v1;
	for (int i = 0; i < 5; i++)
	{
		v1.push_back(i);//尾插
	}

	if (v1.empty())
	{
		cout << "deque容器为空" << endl;
	}
	else
	{
		myPrint(v1);
	}

	//size返回元素个数
	int a = v1.size();
	cout << a << endl;

	//resize(num) ; 重新指定容器大小  ，新添为默认参数 0
	v1.resize(10);
	myPrint(v1);

	//修改新添默认参数  66
	v1.resize(11, 66);
	myPrint(v1);


}

总结：

• deque没有容量的概念
• 判断是否为空 ：empty()
• 返回元素个数：size()
• 重新指定个数：resize（）

3.3…5 deque插入和删除

功能描述：

• 想deque容器中插入和删除数据

函数原型：

两端插入操作：

• push_back(elem); //容器尾部添加一个数据
• push_front(elem); //容器首部添加一个数据
• pop_back(elem); //容器尾部删除一个数据
• pop_front(elem); //容器首部删除一个数据

指定位置操作：

• 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位置的数据，返回下一个数据的位置

void test()
{
	//deque构造函数
	deque v1;
	for (int i = 0; i < 5; i++)
	{
		v1.push_back(i);//尾插
	}

	//首插法
	v1.push_front(1111);
	//尾插法
	v1.push_back(9999);

	myPrint(v1);

	v1.pop_front();//删除首个数据
	v1.pop_back();//删除最后数据
	myPrint(v1);

	//指定位置操作
	v1.insert(v1.begin()+1, 2222);
	myPrint(v1);
	v1.insert(v1.begin() + 2, 3, 3333);
	myPrint(v1);


	v1.erase(v1.begin());
	myPrint(v1);

	v1.erase(v1.begin(), v1.begin()+4);
	myPrint(v1);

	v1.clear();
	myPrint(v1);

}

总结：

• 插入和删除提供的位置是迭代器
• 尾插：push_back（）
• 首插：push_front()
• 尾删：pop_back()
• 首删：pop_front();

3.3.6 deque数据存取

功能描述：

• 对deque中的数据存取操作

函数原型：

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

void test()
{
	//deque构造函数
	deque v1;
	for (int i = 0; i < 5; i++)
	{
		v1.push_back(i);//尾插
	}

	int a = v1.at(1);
	cout << "a=" << a << endl;

	cout << "b = " << v1[2] << endl;

	cout << "第一个元素" << v1.front() << endl;
	cout << "最后一个元素" << v1.back() << endl;
}

总结：

• 除了迭代器获取deque容器中元素，at() , []也可以
• front（）返回容器第一个元素
• back（）返回容器最后一个元素

3.3.7 deque排序

功能描述：

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

算法：

• sort（iterator beg,iterator end）; //对beg和end区间内元素进行排序

void test()
{
	//deque构造函数
	deque v1;
	v1.push_back(20);
	v1.push_back(4);
	v1.push_back(523);
	v1.push_back(5);
	v1.push_back(34);

	sort(v1.begin(), v1.end());//排序 小到大
	myPrint(v1);
}

总结：sort算法默认：从小到大 ，使用时包含头文件 #include

3.5 stack容器 3.5.1 stack基本概念

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

栈中只有顶端的元素才可以被外界使用，因此栈不允许有遍历行为

栈中进入数据成为 ： 入栈 push

栈中弹出数据称为 ： 出栈 pop

3.5.2 stack常用接口

功能描述：栈容器常用的对外接口

构造函数：

• stack stk; //stack采用模板类实现，stack对象的默认构造形式
• stack; //拷贝构造函数

赋值操作：

• stack &operator =(const stack &stk); //重载等号操作符

数据存取：

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

大小操作：

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

void test()
{
	//stack容器
	stack stk;
	stk.push(12);
	stk.push(13);
	stk.push(14);
	stk.push(15);

	while (!stk.empty())
	{
		//查看栈顶元素
		cout << "栈顶的元素为：" << stk.top() << endl;

		//出栈
		stk.pop();
	}
	cout << "栈的大小：" << stk.size() << endl;
}

总结：

• 入栈 ：push（）
• 出栈：pop（）
• 返回栈顶：top()
• 判断是否为空：empty（）
• 返回栈大小：size（）

3.6 queue容器 3.6.1 queue基本概念

**概念：**Queue是一种 先进先出 的数据结构。

• 队列容器允许从一端新添元素，从另一端移除元素
• 队列中只有队头和队尾才可以被外界使用，因此队列不允许有遍历行为
• 队列中进数据称为：入队 push
• 队列中出数据称为：出队 pop

3.6.1queue 常用接口

功能描述：队列容器常用接口

构造函数：

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

赋值操作：

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

数据存取：

• push（elem）；//向队尾添加元素
• pop();//向队头移除第一个元素
• back（）；返回最后一个元素
• front（）；返回第一个元素

大小操作：

• empty（）；//判断堆栈是否为空
• size（）；//返回栈的大小

void test()
{
	//queue队列容器
	queueque;//默认构造
	que.push(1);//队尾添加
	que.push(50);
	que.push(55);
	que.push(22);

	cout << "对首数据：" << que.front() << endl;

	que.pop();   //删除队首数据
	cout << "队尾数据：" << que.back() << endl;

	queue que2(que);  //拷贝构造

	if (!que2.empty())
	{
		cout << "queque的大小：" << que2.size() << endl;
		cout << "队首的元素为：" << que2.front() << endl;
		cout << "对尾的元素为：" << que2.back() << endl;
	}


}

总结：

入队：push

出队：pop

返回对头元素：front

返回队尾元素：back

判断队是否为空：empty

返回队列大小：size

3.7 list容器 3.7.1 list容器基本概念

**功能：**将数据进行链式存储

**链表（list）**是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现

链表的组成：链表由一系列结点组成

结点的组成：一个存储数据元素的数据域 ，另一个是存储下一个结点地址的指针域

STL中的链表是一个双向循环链表

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

list的优点：

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

list的缺点：

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

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

总结：STL中list和vector是两个最常被使用的容器，各有优缺点。

3.7.2 list构造函数

功能描述：

• 创建list容器

函数原型：

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

void test()
{
	//list列表容器
	list lst;   //默认构造
	for (int i = 1; i < 11; i++)
	{
		lst.push_back(i);
	}
	myPrintList(lst);

	//区间构造
	list l2(lst.begin(), lst.end());
	myPrintList(l2);

	//元素构造   8个6
	listl3(8, 6);
	myPrintList(l3);

	//拷贝构造
	listl4(lst);
	myPrintList(l4);


}

3.7.3 list赋值和交换

功能描述：

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

函数原型

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

void test()
{
	//list列表容器
	list lst;   //默认构造
	for (int i = 1; i < 11; i++)
	{
		lst.push_back(i);
	} 
	myPrintList(lst);

	//operator = 赋值
	list l2;
	l2 = lst;    
	myPrintList(l2);

	//assign 赋值
	listl3;
	l3.assign(l2.begin(), l2.end());
	myPrintList(l3);

	//assign 几个元素
	listl4;
	l4.assign(8,6);
	myPrintList(l4);

	//swap交换本身
	l4.swap(l2);
	myPrintList(l2);
	myPrintList(l4);
	

}

3.7.4 list大小操作

**功能描述：**对list容器的大小进行操作

函数原型：

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

void test()
{
	//list列表容器
	list lst;   //默认构造
	for (int i = 1; i < 11; i++)
	{
		lst.push_back(i);
	} 

	if (!lst.empty())
	{
		cout << "该list容器不为空" << endl;
		cout << "容器大小：" << lst.size() << endl;
		
	}

	//resize 重新设置容器大小
	cout << "resize后：" << endl;
	lst.resize(12);    //多的元素，默认参数填充 0
	myPrintList(lst);

	lst.resize(15, 9);  //多的元素，指定参数（9）填充
	myPrintList(lst);

}

3.7.5 list插入和删除

**功能描述：**对list容器进行数据的插入和删除

函数原型：

• 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位置的数据，返回下一个数据的位置
• remove(elem) ; //删除容器中所有与elem值匹配的元素

void test()
{
	//list列表容器
	list lst;   //默认构造
	for (int i = 1; i < 11; i++)
	{
		lst.push_back(i);//尾插
	} 
	lst.push_front(-100);//首插
	lst.push_front(-200);
	lst.push_front(-300);
	lst.push_front(-400);

	myPrintList(lst);

	//删除尾部 ，首部元素
	lst.pop_back();
	lst.pop_front();
	myPrintList(lst);

	//插入数据
	list::iterator it = lst.begin();
	lst.insert(it, 666);
	myPrintList(lst);
	lst.insert(++it, 8, 666);
	myPrintList(lst);

	//删除
	lst.erase(it);

	lst.remove(666);
	myPrintList(lst);
	
	//清空
	lst.clear();
	

}

3.7.6 list数据存取

**功能描述：**对list容器中数据进行存取

数据原型：

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

void test()
{
	//list列表容器
	list lst;   //默认构造
	for (int i = 1; i < 11; i++)
	{
		lst.push_back(i);//尾插
	} 
	
	//list容器数据存储
	int a = lst.front();
	cout << "首元素：" << a << endl;

	int b = lst.back();
	cout << "尾元素：" << b << endl;
	
    //list本质链表 ，不是用连续线性空间存储数据
    //迭代器不支持随机访问 ，支持双向
}

3.7.7 list 反转和排序

**功能描述：**对list容器中元素 进行反转和排序

函数原型：

sort(); //链表排序

reverse(); //反转链表

void test()
{
	//list列表容器
	list lst;   //默认构造
	for (int i = 1; i < 11; i++)
	{
		lst.push_back(i);//尾插
	} 
	myPrintList(lst);

	//反转
	cout << "反转";
	lst.reverse();
	myPrintList(lst);

	//排序   小到大
	cout << "排序";
    //  不能 sort(lst.begin(),lst,end); 所有不支持随机访问迭代器的容器，不可以用标准算法
    //不支持随机访问迭代器的容器，内部会提供对应一些算法
    lst.sort();
	myPrintList(lst);
}

3.8 set/multset 容器 3.8.1 set基本概念

**简介：**所有元素都会在插入时自动被排序

本质：set/multset属于关联式容器，底层结构是用二叉树实现。

set和multset区别：

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

3.8.2 set构造和赋值

**功能描述：**创建set容器以及赋值

构造：

• setst; //默认构造函数
• set(const set&st); //拷贝构造

赋值：

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

void test()
{
	//set容器
	setst;
	//set容器插入数据只有  insert方法
    //set容器特点：所有元素插入时候默认排序（小到大）    不允许插入重复值
	st.insert(10);
	st.insert(80);
	st.insert(30);
	st.insert(40);
	st.insert(50);

	myPrintList(st);

	//拷贝构造
	setst2(st);
	myPrintList(st2);

	//等号赋值 =
	setst3;
	st3 = st;
	myPrintList(st3);
}

3.8.3 set大小和交换

**功能描述：**统计set容器大小以及交换set容器

函数原型：

• size(); //返回容器中元素
• empty(); //判断容器时候为空
• swap(); //交换两个集合容器

void test()
{
	//set容器
	setst;
	//set容器插入数据只有  insert方法
	//set容器特点：所有元素插入时候默认排序（小到大）    不允许插入重复值
	st.insert(10);
	st.insert(200);
	st.insert(30);
	st.insert(40);
	st.insert(50);

	myPrintList(st);

	if (!st.empty())
	{
		cout << "set容器不为空" << endl;
		cout << "容器大小为：" <st2;
	st2.insert(1);
	st2.insert(2);
	st2.insert(3);
	st2.insert(4);
	cout << "st2"< 
3.8.4 set插入和删除 
**功能描述：**set容器进行插入数据和删除数据
 
函数原型：
 
insert(elem); //在容器中插入元素。
clear(); //清除所有元素
erase(pos); //删除pos迭代器所指的元素，返回下一个元素的迭代器。
erase(beg, end); //删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。
erase(elem); //删除容器中值为elem的元素。
 
void test()
{
	//set容器
	setst;
	//set容器插入数据只有  insert方法
	//set容器特点：所有元素插入时候默认排序（小到大）    不允许插入重复值
	st.insert(10);
	st.insert(200);
	st.insert(30);
	st.insert(40);
	st.insert(50);

	myPrintList(st);

	//删除
	st.erase(st.begin());
	myPrintList(st);

	//删除 重载版本
	st.erase(200);
	myPrintList(st);

	//清空
	st.clear();
}
 
3.8.5 set查找和统计 
**功能描述：**对set容器进行查找数据以及统计数据
 
函数原型：
 
find(key); //查找key是否存在，返回该键元素的迭代器；若不存在，返回set.end();
count(key); //统计key的元素个数
 
void test()
{
	//set容器
	setst;
	//set容器插入数据只有  insert方法
	//set容器特点：所有元素插入时候默认排序（小到大）    不允许插入重复值
	st.insert(10);
	st.insert(200);
	st.insert(30);
	st.insert(40);
	st.insert(50);

	myPrintList(st);

	//查找元素
	set::iterator f = st.find(200);
	if (f != st.end())
	{
		cout << "找到元素：" << *f << endl;
        //对于set容器而言，统计结构：1或 0
		cout << "元素的个数：" << st.count(200) << endl;
	}
	else
	{
		cout << "未找到元素" << endl;
	}
}
 
3.8.6 set和multset区别 
**学习目标：**掌握set和multset区别
 
区别：
 
set不可以插入重复数据，而multset可以
set插入数据的同时会返回插入结果，表示插入是否成功
multset不会检测数据，因此可以插入重复数据
 
3.8.7 pair对组创建 
**功能描述：**成对出现的数据，利用对组可以返回两个数据
 
两种创建方式：
 
pair p(value1,value2)
pair p(value1,value2);
 
void test()
{
	//pair对组
	//方式一
	pairp("ac", 24);
	cout << "姓名：" << p.first<< "   年龄：" << p.second << endl;

	//第二种方式
	pairp2 = make_pair("ap", 280);
	cout << "姓名：" << p2.first << "   年龄：" << p2.second << endl;
}
 
3.8.8 set容器排序 
学习目标：
 
set容器默认排序规则为从小到大，掌握如何改变排序规则
 
主要技术点：
 
利用仿函数，可以改变排序规则
 
set容器存放内置数据类型
 
 
3.9 map/multmap 容器 
3.9.1 map基本概念 
简介：
 
map中所有元素都是pair
pair中第一个元素为key（键值）,起到索引作用，第二个元素为value（实值）
所有元素都会根据元素的键值自动排序
 
本质：
 
map/multmap属于关联式容器，底层结构是用二叉树实现
 
优点：
 
可以根据key值快速找到value值
 
map和multmap区别：
 
map不允许容器中有重复key值元素
multmap允许容器中有重复key值元素
 
3.9.2 map构造和赋值 
**功能描述：**对map容器进行构造和赋值操作
 
函数原型：
 
构造：
 
map mp; //map默认构造函数
map(const map &mp) //拷贝构造
 
赋值：
 
map & operator =(const map &mp); //重载等号操作符
 
void myMap( map& m)
{
	for (map::iterator it = m.begin(); it != m.end(); it++)
	{
		cout << "map的键值：" << (*it).first << "   map的实值：" << it->second << endl;
	}
	cout << endl;
}

void test()
{
	//默认构造
	mapmp;
	//map中所有元素都是成对出现的，插入数据时候要使用对组
	mp.insert(pair(1, 10)); 
	mp.insert(pair(2, 20));
	mp.insert(pair(3, 30));
	mp.insert(pair(4, 40));
	myMap(mp);

	//拷贝构造
	mapm2(mp);

	//赋值
	mapm3;
	m3 = mp;
	cout << "m2------------------" << endl;
	myMap(m2);

	cout << "m3--------------------" << endl;
	myMap(m3);
}
 
总结：map中所有元素都是成对出现，插入数据时候要使用对组。
 
3.9.3 map大小和交换 
功能描述：
 
统计map容器大小以及交换map容器
 
函数原型：
 
size(); //返回容器中元素的数目
empty(); //判断容器是否为空
swap(mp); //交换两个集合容器
 
void test()
{
	//默认构造
	mapmp;
	//map中所有元素都是成对出现的，插入数据时候要使用对组
	mp.insert(pair(1, 10)); 
	mp.insert(pair(2, 20));
	mp.insert(pair(3, 30));
	mp.insert(pair(4, 40));
	cout << "mp-----------" << endl;
	myMap(mp);

	//判断是否为空
	if (!mp.empty())
	{
		cout << "mp容器不为空" << endl;
		cout << "mp容器中元素个数为：" << mp.size() << endl;
	}

	mapm2;
	m2.insert(pair(1, 30));
	m2.insert(pair(2, 40));
	cout << "m2-----------" << endl;
	myMap(m2);


	//交换函数
	mp.swap(m2);
	cout << "mp-----------" << endl;
	myMap(mp);
	cout << "m2-----------" << endl;
	myMap(m2);

}
 
3.9.4 map插入和删除 
功能描述：
 
map容器进行插入数据和删除数据
 
函数原型：
 
insert(elem); //在容器中插入元素。
clear(); //清除所有元素
erase(pos); //删除pos迭代器所指的元素，返回下一个元素的迭代器。
erase(beg, end); //删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。
erase(key); //删除容器中值为key的元素。
 
void test()
{
	//默认构造
	mapmp;
	//map中所有元素都是成对出现的，插入数据时候要使用对组
	mp.insert(pair(1, 10)); 
	mp.insert(pair(2, 20));
	mp.insert(pair(3, 30));
	mp.insert(pair(4, 40));
	//插入2
	mp.insert(make_pair(5, 50));
	//插入3
	mp[6] = 60;

	myMap(mp);

	//删除
	mp.erase(mp.begin());
	myMap(mp);

	//按照key删除
	mp.erase(6);
	myMap(mp);
	
	//清空
	mp.clear();
	

}
 
3.9.5 map查找和统计· 
功能描述：
 
对map容器进行查找数据以及统计数据
 
函数原型：
 
find(key); //查找key是否存在，返回该键的元素的迭代器；若不存在，返回set.end();
count(key); //统计key的元素个数
 
void test()
{
	//默认构造
	mapmp;
	//map中所有元素都是成对出现的，插入数据时候要使用对组
	mp.insert(pair(1, 10)); 
	mp.insert(pair(2, 20));
	mp.insert(pair(3, 30));
	mp.insert(pair(4, 40));
	
	//查找
	map::iterator u =mp.find(4);
	if (u != mp.end())
	{
		cout << "查到元素  key= " << (*u).second << endl;
	}

	//统计
	int num = mp.count(2);
	cout << "元素个数：" << num << endl;
	

}
 
3.9.6 map容器排序 
学习目标：
 
map容器默认排序规则为:按照key值 ，从小到大排序 ，掌握如何改变排序规则
 
主要技术点：
 
利用仿函数，可以改变排序规则
 
4 STL -函数对象 
4.1 函数对象概念 
概念：
 
重载函数调用操作符的类，其对象常称为函数对象
函数对象使用重载的()时，行为类似函数调用，也叫仿函数
 
本质：
 
函数对象（仿函数）是一个类，不是一个函数
 
4.1.2 函数对象使用 
特点：
 
函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值
函数对象超出普通函数的概念，函数对象可以有自己的状态
函数对象可以作为参数传递
 
//仿函数
class MyAdd
{
public:
	int operator()(int a, int b)
	{
		return a + b;
	}

};


class myPrint
{
public:
	myPrint()
	{
		this->count = 0;
	}

	void operator()(string text)
	{
		cout << text << endl;
		count++;
	}
	int count;
};

void test01()
{
	MyAdd ad;
	int res =ad(1, 3);
	cout << "res =" << res << endl;
}

void test02()
{
	myPrint myprint;
	myprint("hello world");
	myprint("hello world");
	myprint("hello world");

	cout << "仿函数调用：" << myprint.count <<"次"<< endl;

}

 
4.2 谓词 
4.2.1 谓词基本概念 
概念：
 
返回bool类型的仿函数 称为 谓词
如果operator（）接受一个参数，那么称为一元谓词
如果operator（）接受两个参数，那么称为二元谓词
 
//仿函数，返回值类型bool   称为谓词
//一元谓词
class MyGreat
{
public:
	bool operator()(int val)
	{
		return val > 5;
	}
};

void test()
{
	vectorv;
	for (int i = 1; i < 11; i++)
	{
		v.push_back(i);
	}

	//查找容器中，有没有大于5的数字
	//MyGreat()匿名函数对象
	vector::iterator it =find_if(v.begin(), v.end(), MyGreat());

	if (it == v.end())//没有查到
	{
		cout << "没有查到" << endl;
	}
	else
	{
		cout << "找到了大于5的数字，为：" << *it << endl;
	}



}
 
总结：参数只有一个的参数的谓词，称为一元谓词
 
4.2.3 二元谓词 
//仿函数，返回值类型bool   称为谓词
//二元谓词
class MyGreat
{
public:
	bool operator()(int val1,int val2)
	{
		return val1 > val2;
	}
};

void test()
{
	vectorv;
	v.push_back(20);
	v.push_back(10);
	v.push_back(40);
	v.push_back(90);
	v.push_back(60);
	v.push_back(80);

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

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

	//仿函数  二元谓词，改变排列顺序
	sort(v.begin(), v.end(), MyGreat());

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


}
 
4.3 内建函数对象 
4.3.1 内建函数对象意义 
概念：
 
STL内建了一些函数对象
 
分类：
 
算术仿函数
关系仿函数
逻辑仿函数
 
用途：
 
这些仿函数所产生的对象，用法和一般函数完全相同
 
使用内建函数对象，需要添加头文件 #include
 
4.3.2 算术仿函数 
功能描述：
 
实现四则运算
其中negate是一元运算，其他都是二元运算
 
仿函数原型：
 
template T plus //加法仿函数
template T minus //减法仿函数
template T multiplies //乘法仿函数
template T divides //除法仿函数
template T modulus //取模仿函数
templateT negate //取反仿函数
 
#include

//内建函数 算术仿函数
//negate 一元仿函数     取反仿函数
void test1()
{
	negate n;
	cout << n(50) << endl;
}

//plus 二元仿函数   加法反函数
void test2()
{
	plusp;
	cout << p(10, 20) << endl;
}
 
4.3.3 关系仿函数 
功能描述：
 
实现关系对比
 
仿函数原型：
 
template bool equal_ to //等于
template bool not_ equal_ to //不等于
template bool greater //大于
template bool greater_ equal //大于等于
template bool less //小于
template bool less_ equal //小于等于
 
void test1()
{
	vectorv;
	v.push_back(20);
	v.push_back(40);
	v.push_back(30);
	v.push_back(60);
	v.push_back(90);
	v.push_back(80);

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

	//排序
	sort(v.begin(), v.end(),greater ());

	//遍历
	for (vector::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << (*it) << " ";
	}
	cout << endl;
}
 
4.3.4 逻辑仿函数 
功能描述： 
实现逻辑运算
 
函数原型：
 
template bool logical_ and //逻辑与
template bool logical_ or //逻辑或
template bool logical_ not //逻辑非
 
 
 
 
v;
 v.push_back(20);
 v.push_back(10);
 v.push_back(40);
 v.push_back(90);
 v.push_back(60);
 v.push_back(80);
 
 
sort(v.begin(), v.end());

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

//仿函数  二元谓词，改变排列顺序
sort(v.begin(), v.end(), MyGreat());

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








### 4.3 内建函数对象

#### 4.3.1 内建函数对象意义

**概念：**

- STL内建了一些函数对象

**分类：**

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

**用途：**

这些仿函数所产生的对象，用法和一般函数完全相同

使用内建函数对象，需要添加头文件    #include







#### 4.3.2 算术仿函数

**功能描述：**

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

**仿函数原型：**

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



```c++
#include

//内建函数 算术仿函数
//negate 一元仿函数     取反仿函数
void test1()
{
	negate n;
	cout << n(50) << endl;
}

//plus 二元仿函数   加法反函数
void test2()
{
	plusp;
	cout << p(10, 20) << endl;
}
 
4.3.3 关系仿函数 
功能描述：
 
实现关系对比
 
仿函数原型：
 
template bool equal_ to //等于
template bool not_ equal_ to //不等于
template bool greater //大于
template bool greater_ equal //大于等于
template bool less //小于
template bool less_ equal //小于等于
 
void test1()
{
	vectorv;
	v.push_back(20);
	v.push_back(40);
	v.push_back(30);
	v.push_back(60);
	v.push_back(90);
	v.push_back(80);

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

	//排序
	sort(v.begin(), v.end(),greater ());

	//遍历
	for (vector::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << (*it) << " ";
	}
	cout << endl;
}
 
4.3.4 逻辑仿函数 
功能描述： 
实现逻辑运算
 
函数原型：
 
template bool logical_ and //逻辑与
template bool logical_ or //逻辑或
template bool logical_ not //逻辑非