[C++知识库]爆肝一个月手写C++进阶学习笔记

本人小白一只，欢迎大佬们指点纠正~

C++核心编程

程序的内存模型

1.内存分区模型

·代码区：存放函数的二进制代码，由操作系统进行管理的。（注释不会放到代码区）
·全局区：存放全局变量和静态变量以及常量。（常量为全局常量和字符串常量）
·栈区：由编译器自动分配和释放，存放函数的参数值，局部变量等。（包括局部常量）
·堆区：由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收。

内存四区的意义

不同区域存放的数据，赋予不同的生命周期，给我们更灵活的编程。

1.1 程序运行前

? 在程序编译后，生成exe可执行文件，未执行该程序前分为两个区域

代码区：
	存放CPU执行的机器指令
	代码区是共享的，共享的目的是对于频繁执行的程序，只需要在内存中有一份代码即可。
	代码区是只读的，使其只读的原因是防止程序意外的修改了它的指令。

全局区：
	全局变量和静态变量存放在此。
	全局变量还包含常量区，字符串常量和其它常量也存放在此。
	该区域的数据在程序结束后由操作系统释放。

1.2程序运行后

栈区：
	由编译器自动分配释放，存放函数的参数值，局部变量等。
	注意事项：不要返回局部变量的地址！！栈区开辟的数据由编译器自动释放。

堆区：
	由程序员分配释放，若程序员不释放，程序结束时由操作系统回收。
	在C++中主要利用new在堆区开辟内存。

1.3new操作符

C++中用new操作符在堆中开辟数据
堆中开辟的数据，由程序员手动开辟，手动释放，释放利用操作符delete(释放数组的时候要加[],如：delete[] arr)
语法：new 数据类型
利用new创建的数据，会返回该数据对应类型的指针

2.引用

作用：给变量起别名
语法：数据类型 &别名 = 原名

2.1引用的注意事项

·引用必须初始化  例：int &b；// 错误写法，必须初始化
·引用在初始化后，不可改变

2.2 引用做函数参数

作用：函数传参时，可以利用引用的技术让形参修饰实参
优点：可以简化指针修改实参

2.3 引用做函数的返回值

作用：引用是可以作为函数的返回值存在的
注意：不要返回局部变量的引用
用法：函数调用作为左值  //如果函数的返回值是引用，这个函数可作为左值，这个函数就代表引用的变量

2.4 引用的本质

本质：引用的本质在C++内部实现是一个指针常量

// 发现是引用，转化为 int* const ref = &a
void func(int& ref)
{
    ref = 100; // ref是引用，转化为 *ref = 100
}
int main()
{
    int a = 10;
    //自动转化为 int* const ref = &a; 指针常量是指针的指向不可改，也说明为什么引用不可更改
    int& ref = a;
    ref = 20; // 内部发现ref是引用，自动帮我们转化为：*ref = 20;
}

2.5 常量引用

作用：常量引用主要用来修饰形参，防止误操作
在函数形参列表中，可以加const修饰形参，防止形参修改实参

// 引用使用的场景，通常来修饰形参
void showValue(const int& v)
{
    cout<<v<<endl;
}
int main()
{
    //int& ref = 10  引用本身需要一个合法的内存空间，10为常量，因此词行为错误
    //加入const就可以了，编译器优化代码，int temp = 10; const int& ref = temp; 创建了一个临时变量。
    const int& ref = 10;
    
    //函数中利用常量引用防止误操作修改实参
    int a = 10;
    showValue(a);
}

3 函数提高

3.1 函数默认参数

在C++中，函数的形参列表中的形参是可以有默认值的
语法：返回值类型 函数名 （参数=默认值）{}

注意事项：
		1.如果某个位置已经有了默认参数，那么从这个位置往后，从左到右都必须有默认值。
		2.如果函数声明有默认参数，函数实现就不能有默认参数。（反之亦然）

3.2函数占位参数

C++中函数的形参列表可以有占位参数，用来做占位，调用函数时必须填补该位置

语法：返回值类型 函数名 （数据类型）{}

3.3函数的重载

3.3.1 函数重载概述

作用：函数名可以相同，提高复用性

函数重载满足的条件：
		1.同一个作用域
		2.函数名称相同
		3.函数参数类型不同或者个数不同或者顺序不同
		
注意：函数的返回值不可以作为函数重载的条件

3.3.2 函数重载的注意事项

· 引用作为重载条件（加const与不加const的参数列表不一样）
· 函数重载碰到函数默认参数 例： int func(int a, int b=10）; int func(int a);  这个函数在调用时若只传一个参数会出现二异性 

4.类和对象

C++面向对象的三大特征：封装、继承、多态
C++认为万事万物皆为对象，对象上有其属性和行为

4.1 封装

4.1.1 封装的意义

封装是C++面向对象三大特征之一
封装的意义：
	·将属性和行为作为一个整体，表现生活中的事物
	·将属性和行为加以权限控制
	
意义一：
	在类设计的时候，属性和行为写在一起，表现事物
	语法： class 类名{	访问权限： 属性 / 行为 };
	
意义二：
	类设计时，可以把属性和行为放在不同的权限下，加以控制。
	
	访问权限有三种：
		1.public	公共权限	类内可以访问 类外可以访问
		2.protected	保护权限	类内可以访问 类外不可以访问	可以被子类访问
		3.private	私有权限	类内可以访问 类外不可以访问	不可被子类访问

4.1.2 class 与 struct的区别

在C++中struct与class的唯一区别就在于默认访问权限的不同
区别：
	·struct默认权限为公共
	·class默认权限为私有

4.1.3 成员属性设为私有

优点一：将成员变量设为私有，可以自己控制读写权限
优点二：对于写权限，我们可以检测数据的有效性

4.2对象的初始化和清理

4.2.1 构造函数和析构函数

对象的初始化和清理也是非常重要的安全问题
	一个对象或者变量没有初始化状态，对其使用后果是未知
	同样的使用一个对象或变量，没有及时清理，也会造成一定的安全问题

c++利用构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作。
对象的初始化和清理工作是编译器强制要我们做的事情，因此我们不提供构造和析构，编译器会提供，编译器提供的构造函数和析构函数是空实现。

·构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无需手动调用。
·析构函数：主要作用在对象销毁前系统自动调用，执行一些清理工作。

构造函数语法：类名（）{}
	1.构造函数，没有返回值也不写void
	2.函数名称与类名相同
	3.构造函数可以有参数，因此可以发生重载
	4.程序在调用对象的时候会自动调用构造，无须手动调用，而且只会调用一次
	
析构函数语法：~类名（）{}
	1.析构函数没有返回值也不写void
	2.函数名称与类名相同，在名称前加上符号~
	3.析构函数不可以有参数，因此不可以发生重载
	4.程序在对象销毁前会自动调用析构，无需手动调用，而且只会调用一次

4.2.2构造函数的分类及调用

两种分类方式：
	按参数分类：有参构造和无参构造
	按类型分类：普通构造和拷贝构造

三种调用方式：
	括号法
	显示法
	隐式转换法

//构造函数
Person()
{
    cout<<"Person的无参构造函数调用"<<endl;
}
Person(int a)
{
    cout<<"Person的有参构造函数调用"<<endl;
}
//拷贝构造函数
Person(const Person &p)
{
    //将传入的人身上的所有属性，拷贝到自己身上
    age = p.age;
}

//调用
void test01()
{
    //1.括号法
    Person p1; //默认构造函数调用
    Person p2(10); //有参构造函数
    Person p3(p2);//拷贝构造函数
    
    //注意事项：调用默认构造函数的时候不要加（），因为这段代码会被编译器认为是函数的声明！
    
    //2.显示法
    Person p1 = Person(10);
    //等号右侧为匿名对象（当前行执行结束后，系统会立即回收掉匿名对象），等号左侧为对象名字。
    
    //注意事项：不要用拷贝构造函数初始化匿名对象，编译器会认为 Person(p3) == Person p3 对象的声明
    
    //3.隐式转换法
    Person p4 = 10; //相当于写了 Person p4 = Person(10);
    Person p5 = p4; //拷贝构造
}

4.2.3拷贝构造函数调用时机

c++中拷贝构造函数调用时机通常有三种情况
1、使用一个已经创建完毕的对象来初始化新对象
2、以值传递的方式给函数参数传值
3、以值方式返回局部对象

4.2.4构造函数调用规则

默认情况下，c++编译器至少给一个类添加3个函数
1、默认构造函数（无参，函数体为空）
2、默认析构函数（无参，函数体为空）
3、默认拷贝构造函数，对属性进行值拷贝

构造函数的调用规则：
·如果用户定义了有参构造，编译器不提供默认无参构造，但会提供默认拷贝构造
·如果用户定义了拷贝构造，编译器不提供其它构造函数

4.2.5深拷贝与浅拷贝

浅拷贝：简单的赋值拷贝操作
深拷贝：在堆区重新申请空间，进行拷贝操作。（重写拷贝构造函数，手动在堆区开辟内存）

若对象的属性在堆区中存储需要在析构函数中delet掉

4.2.6初始化列表

作用：
	c++提供了初始化列表语法，用来初始化属性
语法：
	构造函数（数据类型 值1,数据类型 值2,...）：属性1（值1），属性2（值2）...{}
	写在构造函数中可自动将属性赋值，注意冒号！

4.2.7类对象作为类成员

c++中的成员可以是另一个类的对象，我们称该成员为 对象成员
例如：
	class A{}
	class B
	{
		A a;
	}
B类中有对象A作为成员，A为对象成员，先创建A对象再创建B对象

4.2.8静态成员

静态成员就是成员变量和成员函数前加上static，称为静态成员
静态成员分为：
	
	·静态成员变量（通过类名或对象进行访问，类外访问不到私有的静态成员变量）
	 1、所有对象共享一份数据
	 2、在编译阶段分配内存
	 3、类内声明，类外初始化  （在类外 类名::变量名 = 值）
	
	·静态成员函数（通过类名或对象进行访问）
	 1、所有对象共享一个函数
	 2、静态成员函数只能访问静态成员变量

4.3 C++对象模型和this指针

4.3.1成员变量和成员函数分开存储

在c++中，类内的成员变量和成员函数是分开存储的
只有非静态成员变量才属于类的对象上

空对象占用的内存空间为1个字节，是为了区分空对象占内存的位置
每个空对象也应该有一个独一无二的内存地址

4.3.2this指针概念

c++中成员变量与成员函数是分开存储的
每一个非静态成员函数只会诞生一份函数实例，也就是说多个类型的对象会共用一块代码
问题是：这一块代码是如何区分哪个对象调用自己呢？

c++通过提供特殊的对象指针，this指针，解决上述问题。this指针指向被调用的成员函数所属的对象

this指针是隐含在每一个非静态成员函数内的一种指针
this指针不需要定义，直接使用即可

this指针的用途：
·当形参和成员变量同名时，可用this指针来区分
·在类的非静态成员函数中返回对象本身，可以使用return *this 返回类型用引用的方式： 类名&

this指针的本质：
	是指针常量，指针的指向是不可以修改的

4.3.3空指针访问成员函数

c++中空指针也是可以调用成员函数的，但是要注意是否用到this指针
如果用到this指针，需要加以判断保证代码的健壮性

4.3.4const修饰成员函数

常函数：
	·成员函数后加const后我们称为常函数
	·常函数不可以修饰成员属性
	·成员属性声明时加关键字mutable后，在常函数中依然可以修改
	
常对象：
	·声明对象前加const称该对象为常对象
	·常对象只能调用常函数

4.4友元

在程序里，有些私有属性也想让类外特殊的一些函数或者类访问，就需要用到友元技术
友元的目的是让一个函数或者类访问另一个类的私有成员

友元的关键字是 friend

友元的实现（写在类的内部）： 
	·全局函数做友元
	·类做友元
	·成员函数做友元

4.5运算符重载

运算符重载概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型

4.5.1加号运算符重载

作用：实现两个自定义数据类型相加的运算  operater+

对于内置的数据类型的表达式的运算符是不可改变的
不要滥用运算符重载

4.5.2左移运算符重载

作用：可以输出自定义的数据类型  operater<<

一般不会利用成员函数来重载左移运算符，因为无法使cout在左侧，只能利用全局运算符重载
cout属于标准的输出流（ostream）对象

4.5.3 递增运算符重载

作用：通过重载递增运算符，实现自己的整型数据类型  operate++

operator++（int） int 代表占位参数，可以用于区分前置和后置递增，有int为后置递增

前置返回引用，后置返回值

4.5.4赋值运算符重载

c++编译器至少给一个类添加四个函数
 1、默认构造函数（无参，函数体为空）
 2、默认析构函数（无参，函数体为空）
 3、默认拷贝构造函数，对属性进行值拷贝
 4、赋值运算符operator=对属性进行拷贝
 
 如果类中有属性创建在堆区，做赋值操作时也会引发出现深浅拷贝问题

4.5.5关系运算符重载

作用：重载关系运算符，可以直接让两个自定义类型对象进行对比操作。

4.5.6函数调用运算符重载

·函数调用运算符（）也可以重载
·由于重载后使用的方式非常像函数的调用，因此称为仿函数
·仿函数没有固定的写法，非常灵活

匿名函数对象（匿名的对象在此条语句结束后就会被释放）： 对象名（）（值1,值2...） //此（）是被重载过

4.6继承

在定义一些类时，下级别的成员除了拥有上一级的共性，还有自己的特性，此时我们可以用继承技术，减少重复代码。

4.6.1继承的语法

语法： class 子类 ：继承方式 父类
子类也称派生类，父类也称基类。

派生类的成员包含两大部分：
	一类是继承过来的，一类是自己增加的成员。
	从基类继承过来的表现其共性，而新增成员体现了其个性。

4.6.2继承方式

继承语法：class 子类： 继承方式 父类
继承方式共有三种：
	·公共继承  public
	·保护继承  protected
	·私有继承  private
	
子类继承的权限不会高于父类，子类无法访问父类的private

4.6.3继承中的对象模板

子类从父类中继承的所有成员都算在内存中（父类的private也会被继承但不能被访问）

vs利用开发人员命令提示工具查看对象模型：
	1、打开开发人员命令提示工具
	2、跳转到文件所在的路径
	3、输入查看命令： cl/d1 reportSingleClassLayout类名 文件名

4.6.4继承中的构造和析构的顺序

子类继承父类后，当创建子类对象，也会调用父类的构造函数

创建子类对象时：
	先构造父类再构造子类，先析构子类再析构父类

4.6.5继承同名成员处理方式

·访问子类同名成员 直接访问即可
·访问父类同名成员 需要加作用域

如果子类中出现和父类同名的成员函数，子类的同名成员函数会隐藏掉父类中所有同名的成员函数
如果想访问父类中被隐藏的同名成员函数，需要加作用域

4.6.6继承中同名静态成员的处理方式

静态成员和非静态成员出现同名，处理方式一致，只不过有两种访问方法（通过对象或通过类名）

4.6.7多继承语法

c++允许一个类继承多个类

语法：class 子类 ：继承方式 父类1， 继承方式 父类2...

多继承可能会引起父类中有同名成员出现，需要加作用域区分

c++实际开发中不建议使用多继承

4.6.8菱形继承问题

菱形继承概念：
	两个派生类继承同一个基类
	又有某个类同时继承两个派生类
	这样的继承被称为菱形继承，或者钻石继承
	
带来的问题：
	孙类有两份相同的数据，导致资源浪费，利用虚继承可以解决菱形继承问题
	
解决方法：
	利用虚继承，子类在继承父类时在：后继承方式前加上关键字virtual，这样两个子类和孙类都只会公用一份数据

4.7多态

4.7.1多态的基本概念

多态是c++面向对象的三大特征之一

多态分为两类：
	·静态多态：函数重载和运算符重载属于静态多态，复用函数名
	·动态多态：派生类和虚函数实现运行时的多态
	
静态多态和动态多态区别：
	·静态多态的函数地址早绑定-编译阶段确定函数地址
	·动态多态的函数地址玩绑定-运行阶段确定函数地址
	
动态多态满足条件：
	1、有继承关系
	2、子类重写父类的虚函数
动态多态的使用：
	父类的指针或者引用指向子类的对象

重写：函数的返回值类型、函数名、参数列表完全一致

多态的优点：
	·代码组织结构清晰
	·可读性强
	·利于前期和后期的扩展以及维护

4.7.2纯虚函数和抽象类

在多态中，通常父类中虚函数的实现是毫无意义的，主要是调用子类重写的内容，因此可以将虚函数改为纯虚函数。

纯虚函数语法：virtual 返回值类型 函数名 （参数列表）= 0;

当有了纯虚函数，这个类也称为抽象类。

抽象类特点：
	·无法实例化对象
	·子类必须重写抽象类中的纯虚函数，否则也属于抽象类。

4.7.3虚析构和纯虚析构

多态使用时，如果子类中有属性开辟到堆区，那么父类指针释放时无法调用到子类的析构代码

解决方法：将父类中的析构函数改为虚析构或者纯虚析构

虚析构和纯虚析构的共性：
	·可以解决父类指针释放子类对象
	·都需要有具体的函数实现
虚析构和纯虚析构的区别：
	若果是纯虚析构则该类属于抽象类，无法实例化对象
	
虚析构语法： virtual ~类名（）{}

纯虚析构语法： virtual~类名 （）{}=0；

5文件操作

程序运行时产生的数据都属于临时数据，程序一旦运行结束都会被释放
通过文件可以将数据持久化
c++中对文件的操作需要包含头文件<fstream>

文件类型分为两种：
	1、文本文件		-文件以文本的ASCII码形式存储在计算机中
	2、二进制文件		-文件以文本的二进制形式存储在计算机中，用户一般不能直接读懂他们
    
操作文件的三大类：
	1、ofstream：	写操作
	2、ifstream：	读操作
	3、fstream：	读写操作

5.1文本文件

5.1.1写文件

写文件的步骤如下：
1、包含头文件：
	#include<fstream>
2、创建流对象：
	ofstream ofs;
3、打开文件：
	ofs.open("文件路径"，打开方式);
4、写数据：
	ofs<<"写入的数据";
5、关闭文件：
	ofs.close();

文件打开方式：

注意：文件打开方式可以配合使用，利用| 操作符
例如：用二进制方式写文件 ios::binary | ios::out

5.1.2读文件

读文件和写文件步骤相似，但读取方式相对于较多

读文件步骤如下：
 1、包含头文件
 	#include<fstream>
 2、创建流对象
 	ifstream ifs;
 3、打开文件并判断文件是否打开成功
 	ifs.open（"文件路径"，打开方式）;
 	可用 isopen()函数判断文件是否打开成功
 4、读数据
 	四种方式读取
 5、关闭文件
 	ifs.close();

读数据的四种方式：
	//第一种
    char buf[1024] = {0};
	while (ifs>>buf)
    {
	}

	//第二种
	char buf[1024] = {0};
	while (ifs.getline(buf, 1024))
    { 
    }

	//第三种
	String buf;
	while(getline(ifs, buf))
    {
    }

	//第四种 （不推荐使用）
	char c;
	while((c = ifs.get())！=EOF)
    {
	}

5.2二进制文件

以二进制的方式对文件进行读写操作
打开方式要指定ios::binary

5.2.1写文件

二进制方式写文件主要利用流对象调用成员函数write
函数原型：ostream& write(const char*buffer,int len);
参数解释：字符指针buffer指向内存中一段存储空间，len是读写的字节数。

5.2.2读文件

二进制方式读文件主要利用流对象调用成员函数read
函数原型：istream& read(const char*buffer,int len);
参数解释：字符指针buffer 指向内存中一段存储空间，len是读写的字节数。

c++编程提高

本阶段针对c++泛型编程和STL技术进行更深层次的使用

1、模板

1.1模板的概念

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

模板特点：
	·模板不可以直接使用，他只是一个框架
	·模板的通用并不是万能的

1.2函数模板

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

1.2.1函数模板语法

函数模板作用：
	建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟类型来代表
	
语法：
	template<typename T>
	函数声明或定义
解释：
	template ———— 声明创建模板
	typename ———— 表示其后面的符号是一种数据类型，可用class代替
	T ———— 通用数据类型，名称可以替换，通常为大写字母

//交换两个变量的模板
template<typename T> //声明一个模板，告诉编译器后面的代码碰到T不要报错，T是一个通用数据类型
void myswap(T &a, T &b)
{
    T temp = a;
    a = b;
    b = temp;
}

使用模板的两种方式：
	1、自动类型推导
	myswap(a, b)  //让编译器自己去猜测a，b的类型
	2、显示指定类型
	myswap<int>(a, b)  //直接通过<>来告诉编译器指定的类型

1.2.2函数模板注意事项

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

1.2.3普通函数被与函数模板的区别

区别：
	·普通函数调用时可以发生自动类型转换（隐式类型转换）
	·函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
	·如果利用显示指定类型的方式，可以发生隐式类型转换
	
总结：
	建议使用显示指定类型的方式调用函数模板，因为可以自己确定通用类型T。

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

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

1.2.5模板的局限性

模板的通用不是万能的，对于一些特殊数据类型（数组、类）模板就起不到作用。

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

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

1.3类模板

1.3.1类模板语法

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

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

1.3.2类模板与函数模板区别

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

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

类模板中成员函数和普通类中成员函数创建时机是有区别的：
	·普通类中的成员函数一开始就可以创建
	·类模板中的成员函数在调用时才创建

1.3.4类模板对象作函数参数

目标：
	类模板实例化出的对象，向函数传参的方式
	
共有三种传入方式：
	1、指定传入的类型  —— 直接显示对象的数据类型 
	2、参数模板化		—— 将对象中的参数变为模板进行传递
	3、整个类模板化    —— 将这个对象类型模板化进行传递
	
在实际操作中使用第一种指定传入的类型用的比较广泛！

template<class T1, class T2>
class Person
{
public:
    Person(T1 name, T2 age)
    {
        this->m_Name = naem;
        this->m_Age = age;
	}
    void showPerson()
    {
        cout<<"姓名："<<this->m_Name<<"年龄："<<this->m_Age<<endl;
	}
    T1 m_Name;
    T2 m_Age;
}

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

//2、参数模板化
template<class T1, class T2>
void printPerson2(Person<T1, T2>&p)
{
    p.showPerson();
    //查看T1、T2的类型
    cout<<"T1的类型："<<typeid(T1).name()<<endl;
    cout<<"T2的类型："<<typeid(T2).name()<<endl;
}

//3、将整个类模板化
template<class T>
void printPerson3(T &p)
{
    p.showPerson();
}


void test01()
{
    Person<string, int>p("小五"，25);
    printPerson1(p);  //类模板对象作函数参数
}

1.3.5类模板与继承

当我们的类模板碰到继承时，需要注意以下几点：
	·当子类继承的父类是一个类模板时，子类在声明时要指定父类中T的类型
	·如果不指定，编译器无法给子类分配内存
	·如果想灵活指定出父类中的T的类型，子类也需要变为模板

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

//类模板中的成员函数类外实现
template<class T1, class T2>
class Person
{
public:
    //成员函数类内声明
    Person(T1 name, T2 age);
    void showPerson();
public:
    T1 m_Name;
    T2 m_Age;
}

//构造函数类外实现
template<class T1,class T2>
Preson<T1, T2>::Person(T1 name, T2 age)
{
        this->m_Name = naem;
        this->m_Age = age;
}

//成员函数类外实现
template<class T1,class T2>
void Person<T1, T2>::showPerson(T1 name, T2 age)
{
     cout<<"姓名："<<this->m_Name<<"年龄："<<this->m_Age<<endl;
}

1.3.7类模板文件编写

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

1.3.8类模板与友元

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

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

建议全局函数做类内实现（如需友元，也类内声明即可），用法简单，而且编译器可以直接识别！

//全局函数类内实现
#include<iostream>
using namespace std;
#include<string>

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

//全局函数类外实现
#include<iostream>
using namespace std;
#include<string>

//提前让编译器知道Person类的存在，防止函数实现的时候报错
template<class T1, class T2>
class Person;

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

template<class T1, class T2>
class Person
{
    //全局函数类内声明
    //加空参数模板
    //如果全局函数类外实现，需要让编译器提前知道这个函数的存在，所以函数实现放在类的上面
    void printPerson<>(Person<T1,T2>p);
    
public:
    Person(T1 name, T2 age)
    {
        this->m_Name = naem;
        this->m_Age = age;
	}
private:
    T1 m_Name;
    T2 m_Age;
}

1.3.9类模板案例

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

2STL初识

2.1STL的诞生

·长久以来，软件界一直希望建立一种可以重复利用的东西
·c++的面向对象和泛型编程的思想，目的就是复用性的提升
·大多情况下，数据结构和算法都未能有一套标准，导致被迫从事大量重复工作
·为了建立数据结构和算法的一套标准诞生了STL

2.2STL基本概念

STL(Standard Template Library,标准模板库)
STL从广义上分为:容器(container)算法(algorithm)迭代器(iterator)
容器和算法之间通过迭代器进行无缝连接
STL几乎所有的代码都采用了模板类或者模板函数

2.3STL六大组件

STL大体分为六大组件：容器、算法、迭代器、仿函数、适配器（配接器）、空间配置器

1、容器：各种数据结构，如vector、list、deque、set、map等，来存放数据。
2、算法：各种常用的算法，如sort、find、copy、for_each等。
3、迭代器：扮演了容器与算法之间的胶合剂。   	//迭代器不需要多次初始化
4、仿函数：行为类似函数，可作为算法的某种策略。
5、适配器：一种用来修饰容器或者仿函数或迭代器接口的东西。
6、空间适配器：负责空间的配置与管理。

2.4STL中的容器、算法、迭代器

算法只有通过迭代器才能访问容器中的元素

容器： 置物之所也
STL容器就是将运用最广泛的数据结构实现出来。
常用的数据结构：数组、链表、树、栈、队列、集合、映射表等。
这些容器分为 序列式容器 和 关联式容器 两种：
	序列式容器：强调值得排序，序列式容器中得每个元素均有固定得位置。
	关联式容器：二叉树结构，各元素之间没有严格的物理上得顺序关系。
	
算法： 问题之解法也
有限的步骤，解决逻辑或数学上的问题，这一门学科我们叫做算法(Algorithms)
算法的分类：质变算法 和 非质变算法：
	质变算法：是指运算过程中会更改区间内容元素的内容，例如：拷贝、替换、删除等等。
	非质变算法：是指运算过程中不会更改区间内元素的内容，例如查找、计数、遍历、寻找极值等等。
	
迭代器： 容器和算法之间的粘合剂
提供一种方法，使之能够依次寻访某个容器所含的各个元素，而又无需暴露该容器的内部表示方式。
每个容器都有自己专属的迭代器
迭代器的使用非常类似于指针，初学阶段我们可以先理解迭代器为指针

常用的容器中的迭代器种类为双向迭代器、h

迭代器种类：

2.5容器、算法、迭代器初识

STL中最常见的容器为Vector，可以理解为数组

2.5.1vector存放内置数据类型

容器：vector
算法：for_each
迭代器：vector<int>::iterator

#include<vector>
#include<algorithm>   //标准算法的头文件

void MyPrint(int val)
{
    cout<<val<<end;
}

void test01()
{
    //创建vector容器对象，并且通过模板参数指定数据类型
    vector<int> v;
    //向容器中存放数据
    v.push_back(10);
    v.push_back(20);
    v.push_back(30);
    
    //通过迭代器访问容器中数据
    vector<int>::iterator itBegin = v.begin(); //起始迭代器，指向容器第一个元素
    vector<int>::iterator itEnd = v.end();  //结束迭代器，指向容器最后一个元素的下一个位置
    
    //第一种遍历方式
    while(itBegin != itEnd)
    {
        cout<< *itBegin <<endl;
        itBegin++;
    }
    
    //第二种遍历方式
    for(vector<int>::iterator it = v.begin(); it != v.end(); it++)
    {
        cout<< *it <<endl;
	}
    
    //第三种遍历方式  利用STL提供的遍历算法
    for_each(v.begin(),v.end(), MyPrint);  //参数：起始位置 ， 结束位置 ， 自定义要调用的函数
}

2.5.2vector存放自定义数据类型

#include<vector>
#include<string>

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

//存放对象
void test01()
{
    vector<Person> v;
    
    //创建数据
    Person p1("小五", 25);

    v.push_back(p1);
    
    for(vector<Person>::iterator it = v.begin(); it != v.end(); it++)
    {
        //第一种方式，利用解引用  *it的数据类型就是vector中<>里面的数据类型
        cout<<"姓名："<< (*it).m_Name << "年龄：" << (*it).m_Age << endl;
        
        //第二种方式，直接利用it指针
        cout<<"姓名："<< it->m_Name << "年龄：" << it->m_Age << endl;
    }
}

//存放对象指针
void test01()
{
    vector<Person*> v;
    
    //创建数据
    Person p2("小六", 26);

    v.push_back(&p2);
    
    for(vector<Person*>::iterator it = v.begin(); it != v.end(); it++)
    {
        // *it的数据类型就是vector中<>里面的数据类型！！
        cout<<"姓名："<< (*it).m_Name << "年龄：" << (*it).m_Age << endl;
    }
}

2.5.3vector容器嵌套容器

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

//容器嵌套容器
void test()
{
    vector<vector<int>> v;
    
    //创建小容器
    vector<int>v1;
    vector<int>v2;
    vector<int>v3;
    
    //向小容器种添加数据
    v1.push_back(i+1);
    v2.push_back(i+2);
    v3.push_back(i+3);
    
    //将小容器插入大容器中
    v.push_back(v1);
    v.push_back(v2);
    v.push_back(v3);
    
    //通过大容器，把所有数据遍历一遍
    for(vector<int>::iterator it = v.begin(); it != v.end(); it++)
    {
        //(*it)----容器vector<int>
        for(vector<int>::iterator vit = (*it).begin;vit != (*it).end();vit++)
        {
            cout<<*vit<<" ";
        }
        cout<<endl;
    }
    
}

3STL容器

3.1.1 string基本概念

本质：
	·string是c++风格的字符串，而string本质上是一个类

string和char*的区别：
	·char*是一个指针
	·string是一个类，类内部封装了char*，管理这个字符串，是一个char*型的容器。

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

3.1.2string的构造函数

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

3.1.3string的赋值操作

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

string的赋值方式有很多，一般operator=这种方式比较实用

3.1.3string字符串拼接

功能描述： 实现字符串的末尾拼接字符串

函数原型：
	·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 string& str)
	·string& append(const string &s, int pos, int n);  //字符串s从pos开始的n个字符连接到字符串的末尾

3.1.5string查找和替换

功能描述：
	·查找：查找指定字符是否存在
	·替换：在指定的位置替换字符
函数原型：
	·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 rfing(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
 
rfind和find的区别：
	rfind从右往左查找
	find从左往右查找
	
·find找到字符串后返回返回查找的第一个字符的位置，找不到返回-1

·replace在替换时，要指定从哪个位置起，多少个字符，替换成什么样的字符串

3.1.6string字符串比较

 功能描述：
 	字符串之间的比较
 比较方式：
 	字符串比较的是ASCII码
 	
 	= 返回 0
 	> 返回 1
 	< 返回 -1
函数原型：
	int compare(const string &s) const;  //与字符串s比较
	int compare(const char *s) const;  //与字符串s比较

3.1.7string字符存取

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

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

3.1.8string中的插入和删除

功能描述：
	·对string字符串进行插入和删除字符操作
函数原型：
	·string& inset(int pos,const char* s);  //插入字符串
	·string& insert(int pos,const string& str); //插入字符串
	·string& inset(int pos, int n, char c);  //在指定位置插入n个字符串
	·string& erase(int pos, int n = npos); //删除pos开始的n个字符

注意：
	插入和删除的起始下标都是从0开始

3.1.9string子串

功能描述：
	从字符串中获取想要的字串
函数原型：
	·string substr(int pos = 0,int n = npos)const; //返回由pos开始的n个字符组成d

3.2vector容器

3.2.1vector基本概念

功能：
	vector数据结构和数组非常相似，也成为单端数组

vector与普通数组的区别;
	不同之处在于数组是静态空间，而vector可以动态扩展
	
动态扩展：
	并不是在元空间之后续接新空间，而是找到更大的内存空间，然后将原数据拷贝到新空间，释放原空间。
	
vrctor容器的迭代器是支持随机访问的迭代器

3.2.2vector构造函数

功能描述：
	创建vector容器
函数原型：
	vector<T> v;  //采用类模板实现，默认构造函数
	vector<T>v1(v.begin(), v.end());  //将v[begin(),end())区间中的元素拷贝给v1
	vector<T>v2(n, elem);  //构造函数将n个elem拷贝给v2
	vector<t>v3(const vector &vec);  // 拷贝构造函数

3.2.3vector容器的赋值操作

功能描述：
	给vector容器进行赋值
函数原型：
	vector& operator=(const vector &vec); //重载赋值运算符
	assign(beg, end);  //将[beg,end)区间中的数据拷贝赋值给自身
	assign(n, elem);  //将n个elem拷贝赋值给自身

3.2.4vector容器的容量和大小

功能米描述：
	对vector容器的容量和大小操作
函数原型;
	empty();  //判断容器是否为空
	capacity(); //容器的容量
	size();  //返回容器中元素的个数
	resize(int num);  //重新指定容器的长度为num，容器变长，则以默认值填充新位置，
					//如果变短，则末尾超出容器长度的元素被删除
	resize(int num,elem);  //重新指定容器的长度为num，若容器变长则用elem来填充新位置，
						 //若容器变短，则末尾超出容器长的的元素被删除

3.2.5vector插入和删除

功能描述：
	对vector容器进行插入、删除等操作
函数原型：
	push_back(ele);  //尾部插入元素ele
	pop_back();     //删除最后一个元素
	insert(const_itreator pos, ele);  //迭代器向位置pos插入元素ele
	insert(const_itreator pos, int count,ele);  //迭代器向位置pos插入元素count个ele
	erase(const_iterator pos);    //删除迭代器指向的元素
	erase(const_iterator start,cosnt_iterator end);   //删除迭代器从start到end之间的元素
    clear();   //删除容器中所有元素

3.2.6vector数据存取

功能描述：
	对vector中的数据的存取操作
函数原型：
	at(int idx);	//返回索引idx所指的数据
	operator[];	//返回索引idx所指的数据
	front();		//返回容器中第一个数据元素
	back();			//返回容器中最后一个数据元素

3.2.7vector互换容器

功能描述：
	实现两个容器内元素互换
函数原型：
	swap(vec);	//将vec本身的元素互换
	
实际用途：
	//巧用swap收缩内存
	vector<int>(v).swap(v);  //匿名对象在本行执行完空间会被回收

3.2.8vector预留空间

功能描述：
	减少vector在动态扩展容量时的扩展次数
	
函数原型：
	reserve(int len);  //容器预留len个元素的长度，预留位置不初始化，元素不访问

3.3deque容器

3.3.1deque容器基本概念

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

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

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

3.3.2deque构造函数

功能描述：
	deque容器构造
函数原型：
	·deque<T> deqT;	//默认构造函数
	·deque(beg, end); //构造函数将[beg,end)区间的元素拷贝到自身
	·deque(n, elem);  //构造函数将n个elem拷贝给自身
	·deque(const deque &deq);  //拷贝构造函数

3.3.3deque赋值操作

功能描述：
	给deque容器进行赋值操作
函数原型：
	·deque& operator=(const deque &deq);  //重载等号操作符
	·assign(beg, end);	//将[beg, end)区间中的数据赋值给自身
	·assign(n, elem);	//将n个elem拷贝赋值给本身

3.3.4deque大小操作

功能描述：
	对dep容器的大小进行操作
函数原型：
	·deque.empty();	//判断容器是否为空
	·deque.size()；	//返回容器中的元素个数
	·deque.resize();	//重新指定容器长度为num，若容器变长，则以0填充新位置。
					   //如果容器变短，则末尾超出容器长度的元素被删除
	·deque.resize(num, elem);	//重新指定容器长度为num，若容器变长，则以elem值填充新位置。
							  //如果容器变短，则末尾超出容器长度的元素被删除

3.3.5deque插入和删除

功能描述：
	向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位置的数据，返回下一个数据的位置

3.3.6deque 数据存取

功能描述：
	对deque中的数据的存取操作
函数原型：
	·at(int idx);	//返回索引idx所指的数据
	·operator[];	//返回索引idx所指的数据
	·front();		//返回容器的第一个元素
	·back();		//返回容器中

3.3.7deque排序

功能描述：
	利用算法实现deque容器的排序
算法：
	sort(iterator beg, iterator end)  //对beg和end区间元素进行排序，默认规则从小到大
	对于支持随机访问的迭代器容器，都可以利用sort算法进行排序

3.4stack容器

3.4.1stack基本概念

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

栈中只有顶端的元素才可以被外界使用，因此栈不允许有遍历行为
栈可以判断容器是否为空
栈可以返回元素个数

3.4.2stack常用接口

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

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

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

数据存取：
	push(elem);	//向栈顶添加元素
	pop();		//从栈顶移除第一个元素
	top();		//返回栈顶元素
	
大小操作：
	empty();	//判断堆栈是否为空
	size();		//返回栈的大小

3.5queue容器

3.5.1queue基本概念

概念：queue是一种先进后出的数据结构，他有两个出口
push向队尾添加数据，pop删除队头的数据

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

3.5.2queue常用接口

功能描述：
	队列容器常用的对外接口
	
构造函数：
	queue<T> que;	//queue采用模板类实现，queue对象的默认构造形式
	queue(const queue &que);	//拷贝构造函数
赋值操作：
	queue& operator(const queue &que);	//重载等号操作符
数据存取：
	push(elem);		//往队尾添加元素
	pop();			//从队头移除第一个元素
	back();			//返回最后一个元素
	front();		//返回第一个元素
大小操作：
	empty();		//判断堆栈是否为空
	size();			//返回栈的大小

3.6list容器

3.6.1list基本概念

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

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

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

STL中的链表是一个双向循环链表
双向：每一个节点即记录下一个节点的位置也记录上一个节点的位置
循环：第一个节点记录会记录最后一个节点的位置，最后一个节点会记录第一个节点的位置

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

链表的优点：可以对任意位置进行快速插入或删除元素；采用动态存储分配不会造成内存的浪费和溢出；执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素

链表的缺点：容器遍历速度没有数组快，占用空间比数组大；链表灵活，但是空间（指针）和时间（遍历）额外消耗较大；List有一个重要的性质，插入和删除操作都不会造成原有list迭代器的失效，这在vector是不成立的

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

3.6.2list构造函数

功能描述：
	创建list容器
函数原型：
	list<T> lst;	//list采用模板类实现，对象的默认构造形式
	list<T>(beg,end);	//构造函数将[beg,end)区间中的元素拷贝给自身
	list(n,elem);		//构造函数将n个elem拷贝给自身
	list(const list &lst);	//拷贝构造函数

3.6.3list赋值交换

功能描述：
	给list容器进行赋值，以及交换list容器
函数原型：
	assign(beg,end);	//将[beg,end)区间的数据拷贝赋值给本身
	assign(n, elem);	//将n个elem元素赋值给自身
	list& operator=(const list &lst);	//重载等号操作符
	swap(lst);		//将lst与本身元素互换

3.6.4lis大小操做

功能描述：
	对list容器的大小进行操作
函数原型：
	size();	//返回容器中的元素个数
	empty();	//判断是否为空
	resize(num);	//重新指定容器长度为num，若容器变长以默认值0来填充新位置
				   //如果容器变短，则末尾超出的元素被删除
	resize(num,elem);	//重新指定容器长度为num，若容器变长以elem值来填充新位置
					   //如果容器变短，则末尾超出的元素被删除

3.6.5list插入和删除

功能描述：
	对list容器进行数据的插入和删除
函数原型：
	push_back(elem);	//在容器尾部加入一个元素
	pop_back();			//删除容器中最后一个元素
	push_front(elem);	//在容器的开头插入一个元素
	pop_fronr();		//删除容器开头的第一个元素
	insert(pos,elem);	//在pos位置插入elem元素的拷贝，返回新数据的位置
	insert(pos,n,elem);	//在pos位置插入n个elem元素，无新返回值
	insert(pos,beg,end);	//在pos位置插入[beg,end)区间的数据，无返回值
	clean();		//移除容器中所有的数据
	erase(beg,end);	//移除区间[beg,end)区间的数据，返回下一个数据的位置
	erase(pos);		//删除pos位置的元素，返回下一个元素的数据
	remove(elem);	//删除容器中所有与elem匹配的元素
	
注意：
	insert、erase用的都是迭代器

3.6.6list数据存取

功能描述：
	对list容器中的数据进行存取
函数原型：
	front();	//返回第一个元素
	back();		//返回最后一个元素
	
注意：
	list不支持随机访问如 [ ] 和 at()
	list迭代器只支持 ++、-- 的操作，不可以跳着走，  因为是双向迭代器所以支持--操作

3.6.7list反转和排序

功能描述：
	将容器中的元素反转，以及将容器中的数据进行排序
函数原型：
	reverse();	//反转链表
	sort();		//链表排序，默认排序规则从小到大

所有不支持随机访问的迭代器容器都不可以用标准算法
不支持随机访问的迭代器容器内部会提供一些算法

sort()实现降序排序：
	//自己编写函数
	
	bool myCompare(int v1,int v2)
	{
		//降序 让第一个数>第二个数
		return v1 > v2;
	}
	
	void test()
	{
		list<int>L;
		L.push_back(10);
		L.push_back(40);
		L.push_back(20);
		L.push_back(30);
		
		L.sort(myCompare);
	}

3.8set/multiset容器

3.8.1set基本概念

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

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

set与multiset的区别：
	·set不允许容器内有重复的元素
	·multiset允许容器内有重复的元素

3.8.2set构造和赋值

功能描述：
	创建set容器以及赋值
构造：
	set<T> st;	//默认构造函数
	set(const set &st);	//拷贝构造函数
赋值：
	set& operator=(const set &st) //重载等号操作符

3.8.3set大小和交换

功能描述：
	统计set容器大小以及交换set容器
函数原型：
	size();	//返回容器中元素的数目
	empty();//判断容器是否为空
	swap();	//交换两个集合r

3.8.4set插入和删除

功能描述：
	set容器进行插入数据和删除数据
函数原型：
	insert(elem);	//在容器中插入元素
	clear();		//清除所有元素
	erare(pos);		//删除pos迭代器所指的元素，返回下一元素的个迭代器
	erase(elem);	//删除容器中值为elem的元素

3.8.5set查找和统计

功能描述：
	对set容器进行查找数据以及统计数据
函数原型：
	find(key);		//查找key是否存在，返回该元素的迭代器；若不存在，返回set.end();
	count(key);		//统计key的元素个数

3.8.6set和multis

目标：
	掌握set和multiset的区别
区别：
	·set不可以插入重复数据，而multiset可以
	·set插入数据的同时会返回结果，表示插入成功
	·multiset不会检测数据，因此可以插入重复数据

3.8.7pair对组创建

功能描述：
	成对出现的数据，利用对组可以返回两个数据
两种创建方式：
	pair<type,type> p (value1,value2);
	pair<type,type> p = make_pair(value1,value2);

void test()
{
	//第一种方式
    pair<string,int>p("小五"，25);
    cout<<"姓名："<<p.first<<"年龄："<<p.second<<endl;
    
    //第二种方式
    pair<string,int>p1=make_pair("小六"，26);
    cout<<"姓名："<<p1.first<<"年龄："<<p1.second<<endl;
}

3.8.8set容器排序

目标：
	set容器默认排序规则为从小到大，掌握如何改变排序规则
主要技术点：
	利用仿函数，可以改变排序规则
	在还没有插入数据时就要告诉容器要使用的排序规则

//set排序内置数据类型

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

//利用仿函数吧技术重新定义排序规则
class MyCompare
{
 public:
    bool operator()(int v1,int v2)
    {
        //降序排序
        return v1>v2;
    }
}

void test()
{
    //在模板参数列表中加入将仿函数的名称
    set<int,MyCopmpare> s1;
    s1.insert(10);
    s1.insert(40);
    s1.insert(20);
    s1.insert(30);
}

//set对自定义数据类型进行排序

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

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

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

void test()
{
    //自定义数据类型都需要指定排序规则
    set<int,comparePerson>s;
    
    //创建对象
    Person p1("小五"，25);
    Person p2("小六"，26);
    Person p3("小七"，27);
    Person p4("小八"，28);
    
    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<<"年龄："<<it->m_Age<<endl;
    }
}

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

3.9map/multimap 容器

3.9.1map基本概念

简介：
	·map中所有元素都是pair
	·pair中第一个元素为key(键值)，起到索引作用，第二个元素为value(实值)
	·所有元素都会根据元素的键值自动排序
本质：
	map/multimap属于关联式容器，底层结构是用二叉树实现
优点：
	可以根据key值快速找到value值
map和multimap区别：
	·map容器中不允许有重复的key值元素
	·multimao容器允许有重复的key值元素

3.9.2 map构造函数

功能描述：
	对map容器进行构造和赋值操作

函数原型：

构造：
	map<T1,T2>mp;	//map默认构造函数 T1是key值，T2是value值
	map(const map &map);	//拷贝构造函数
赋值：
	map& operator=(const map &map);		//重载等号操作符
	
map容器中在插入数值是要使用对组

3.9.3map大小和交换

功能描述：
	统计map容器的大小以及交换map容器

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

3.9.4map插入和删除

功能描述：
map容器进行插入数据和删除数据
函数原型：
insert(elem);	//在容器中插入元素
clear();		//清楚所有元素
erase(pos);		//删除pos迭代器所指的元素，返回下一个元素的迭代器
erase(beg,end);	//删除区间[beg,end)的所有元素，返回下一个元素的迭代器
erase(key);		//删除容器中值为key的元素

四种插入方式：
·insert(pair<T1,T2>(值1，值2));		
·insert(make_pair(值1，值2));
·insert(map<T1,T2>::value_type(值1，值2));
·m[key值]=value值;	不建议用[]插入，可以用key访问到value

3.9.5map查找和统计

功能描述：
	对map容器进行查找数据以及统计数据
函数原型：
	find(key);		//查找key是否存在，若存在，返回该键的元素的迭代器；若不存在，返回set.end();
	count(key);		//统计key的元素个数，map只可能为0或1，multimap可能大于1

3.9.6map容器排序

目标：
	map容器默认排序规则为 按照key值进行从小到大排序，掌握如何改变排序规则
主要技术点：
	利用仿函数，可以改变排序规则，在模板参数列表里加入仿函数名称

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

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

void test()
{
    map<int,int,MyCompare>m;
    m.insert(make_pair(1,10));
    m.insert(make_pair(2,20));
    m.insert(make_pair(4,40));
    m.insert(make_pair(3,30));
    m.insert(make_pair(5,50));
    
    for(map<int,int,MyCompare>::iterator it = m.begin();it != m.end(); it++)
    {
        cout<<"key:"<<it->first<<"value:"<<it->second<<endl;
    }
}

4STL函数对象（仿函数）

4.1函数对象

4.1.1函数对象概念

概念：
	·重载函数调用操作符的类，其对象常称为函数对象
	·函数对象使用重载的()时，行为类似函数调用，也叫仿函数
本质：
	函数对象(仿函数)是一个类，不是一个函数

4.1.2函数对象使用

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

4.2谓词

4.2.1谓词概念

谓词：返回bool类型的仿函数

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

4.3内建函数对象

4.3.1内建函数对象的意义

概念：
	STL内建了一些函数对象
分类：
	·算数模仿函数
	·关系仿函数
	·逻辑仿函数

用法：
	·这些仿函数所生产的对象，用法和一般函数完全不同
	·使用内键函数对象，需要引进头文件#inlcude<functional>

4.3.2算术仿函数

功能描述：
	·实现四则运算
	·其中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>		//取反仿函数	

//内建函数对象  算术仿函数

//negate 一元仿函数	取反运算
void test()
{
    negate<int>n;
    
    cout<<n(50)<<endl;
}

//plus 二元仿函数	加法
void test01()
{
    plus<int>p;
     cout<<p(10,20)<<endl;
}

4.2.4逻辑仿函数

功能描述：
	实现逻辑运算
函数原型：
	·template<class T> bool logical_and<T>		//逻辑与
    ·template<class T> bool logical_or<T>		//逻辑或
    ·template<class T> bool logical_not<T>		//逻辑非

5STL-常用算法

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

5.1常用遍历算法

目标：
	掌握常用的遍历算法
算法简介：
	for_each	//遍历容器
	transform	//搬运容器到另一个容器中

5.1.1for_each

功能描述：
	实现遍历容器
函数原型：
	for_each(iterator beg, iterator end, _func)
	//遍历算法 遍历容器元素
	//beg 开始迭代器
	//end 结束迭代器
	//_func 函数或者函数对象(仿函数)

5.1.2transform

功能描述：
	搬运容器到另一个容器中
函数原型：
	transform(iterator beg1, iterator end1, iterator beg2, _func);
	//beg1 源容器开始迭代器
	//end1 源容器结束迭代器
	//beg2 源容器开始迭代器
	//_func 函数或函数对象

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

//常用遍历函数transform

//可以利用函数对象对容器中的元素进行操作
class Transform
{
public:
    int operator()(int v)
    {
        return v;
	}
}

class MyPrint
{
public:
    void operator()(itn val)
    {
        cout<<val<<" ";
    }
}

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(), Transform());
    
    for_each(vTarget.begin(),vTarget.end(), MyPrint());
    cout<<endl;
}

5.2常用的查找算法

目标：
	掌握常用的查找算法
	
算法简介：
	·find		//查中元素
	·find_if	//按条件查找元素
	·adjacent_find	//查找相邻重复元素
	·binary_search	//二分查找法
	·count			//统计元素个数
	·count_if		//按条件统计元素个数

5.2.1find

功能描述：
	查找指定元素，找到返回指定元素的迭代器，找不到返回结束迭代器end()
	
函数原型：
	·find(iterator beg, iterator end, value);
	//beg 开始迭代器
	//end 结束迭代器
	//value 查找的元素

注意：
	find可以在容器中找指定的元素，但返回的是一个迭代器

//查找自定义数据类型
#include<iostream>
#include<vector>
#include<algorithm>
#inlcude<string>

class Person
{
public:
    string m_Name;
    int m_Age;
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;
        }
    }
} 

void test()
{
	//创建数据
    Person p1("小五"，25);
    Person p2("小六"，26);
    Person p3("小七"，27);
    Person p4("小八"，28);
    
    //插入数据
    vector<Pesron>v;
    v.push_back(p1);
    v.push_back(p2);
    v.push_back(p3);
    v.push_back(p4);
    
    //用find查找自定义数据类型
    vector<person> ::iterator it = find(v.begin(), v.end(), p2);
    if(it == v.end())
    {
        cout<<"没有找到"<<endl;
    }
    else
    {
        cout<<"找到了 姓名："<<it->m_Name<<"年龄："<<it->m_Age<<endl;
    }
}

int mian()
{
    test();
    return 0;
}

5.2.2find_if

功能描述：
	按条件查找元素
函数原型：
	·find_if(iterator beg, iterator end, _Perd);
	//按值查找元素，找到则返回指定位置迭代器，找不到返回结束迭代器位置
	//beg 开始迭代器
	//end 结束迭代器
	//_Perd 函数或者谓词(返回bool类型的反函数)

5.2.3adjacent_find

功能描述：
	查找相邻重复元素
函数原型：
	·adjacent_find(iterator beg, iterator end)；
	//查找相邻重复元素，返回相邻重复元素的第一个位置的迭代器
	//beg 开始迭代器
	//end 结束迭代器

5.2.4binary_search

功能描述：
	查找指定元素是否存在
函数原型：
	·bool binary_search(iterator beg, iterator end, value);
	//查找指定的元素，查到返回ture否则false
	//注意：二分查找法，在无序数组中不可用！
	//beg：开始迭代器
	//end：结束迭代器
	//value 查找的元素

5.2.5count

功能描述：
	统计元素个数
函数原型：
	·count(iterator beg, iterator end,value)
	//统计元素出现次数
	//beg开始迭代器
	//end结束迭代器
	//value统计的元素

5.2.6count_if

功能描述：
	按条件统计元素个数
函数原型：
	·count_if(iterator beg, iterator end, _Perd);
	//按条件统计元素出现次数
	//beg开始迭代器
	//end结束迭代器
	//_Perd 谓词 

5.3常用排序算法

学习目标：
	掌握常用的排序算法
算法简介：
	·sort		//对容器内元素进行排序
	·random_shuffle	//洗牌 指定还未内的元素随机调整次序
	·merge		//容器元素合并。并存储到另一个容器
	·revealse	//反转指定范围的元素

5.3.1sort

功能描述：
	对容器内元素进行排序
函数原型：
	·sort(iterator beg, iterator end, _Perd)
	//默认从小到大排序， 可用greater<int>()按照从大到小排序
	//beg开始迭代器
	//end结束迭代器
	//_Perd 谓词 

5.3.2 random_shuffle

功能描述：
	·洗牌 指定范围内的元素随机调整次序
函数原型：
	·random_shuffle(iterator beg, iterator end);
	//指定范围内的元素随机调整次序
	//beg 开始迭代器
	//end 结束迭代器

5.3.3merge

功能描述：
	两个容器元素合并，并存储到另一容器中
函数原型：
	·merge(iterator betg1, iterator end1, iterator beg2, iterator end2, iterator dest);
	//容器元素合并，并存储到另一个容器中
	//注意：两个容器必须有序！
	//beg1 容器1开始迭代器
	//end1 容器1结束迭代器
	//beg2 容器2开始迭代器
	//end2 容器2结束迭代器
	//dest 目标容器开始迭代器
注意：
	目标容器在放入数据之前一定要resize()

5.3.4 reverse

功能描述：
	将容器内元素进行反转
函数原型：
	·reverse(iterator beg,iterator end);
	//反转指定范围的元素
	//beg 开始迭代器
	//end 结束迭代器

5.4常用的拷贝和替换算法

学习目标：
	掌握常用的拷贝和替换算法
算法简介：
	·copy		//容器内指定范围的元素拷贝到另一个容器中
	·replace	//将容器内指定范围的旧元素修改为新元素
	·replace_if	//容器内指定范围且满足条件的元素替换为新元素
	·swap		//互换两个容器的元素

5.4.1 copy

功能描述：
	容器内指定范围的元素拷贝到另一个容器中
函数原型：
	·copy(iterator beg, iterator end, iterator dest);
	//beg 开始迭代器
	//end 结束迭代器
	//dest 目标容器开始迭代器
	
注意：
	目标容器在插入数据之前要进行resize()

5.4.2 replace

功能描述：
	将容器内指定范围的旧元素修改为新元素
函数原型：
	·replace(iterator beg, iterator end, oldvalue, newvalue);
	//将区间内旧元素替换为新元素
	//beg 开始迭代器
	//end 结束迭代器
	//oldvalue 旧元素
	//newvalue 新元素

5.4.3 replace_if

功能描述：
	将区间内满足条件的元素替换成指定元素
函数原型：
	·replace_if(iterator beg,iteraator end, _Perd, newvalue)
	//按条件替换元素，满足条件的替换成指定元素
	//beg 开始迭代器
	//end 结束迭代器
	//_Perd 谓词
	//newvalue 替换的新元素

5.4.4 swap

功能描述：
	互换两个容器的元素
函数原型：
	·swap(container c1, container c2);
	//互换两个容器的元素
	//c1 容器1
	//c2 容器2
	
注意：
	swqp交换容器时，注意交换的容器要是同种类型

5.5算术生成算法

目标：
	掌握常用的算术生成算法
注意：
	算术生产算法属于小型算法，使用时包含头文件 #include<numeric>
	
算法介绍：
	·accumulate	//计算容器元素累计总和
	·fill		//向容器中添加元素

5.5.1 accumulate

功能描述：
	计算区间内容器元素累计总和
函数原型：
	·accumulate(iterator beg, iterator end, value);
	//计算容器元素累计和
	//beg 开始迭代器
	//end 结束迭代器
	//value 起始值

5.5.2 fill

功能描述：
	向容器中填充指定的元素
函数原型;
	·fill(iterator beg, iterator end, value);
	//向容器中填充元素
	//beg 开始迭代器
	//end 结束迭代器
	//value 填充的值

5.6 常用的集合算法

目标：
	掌握常用的集合算法
算法简介：
	·set_intersection		//求两个容器的交集
	·set_union 				//求两个容器的并集
	·set_difference			//求两个容器的差集

5.6.1 set_intersection

功能描述：
	求两个容器的交集
函数原型：
	·set_intersection(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);
	//求两个容器的交集
	//注意：两个容器必须是有序序列！
	//beg1 容器1开始迭代器
	//end1 容器1结束迭代器
	//beg2 容器2开始迭代器
	//end2 容器2结束迭代器
	//dest 目标容器开始迭代器
	//目标容器插入数据前先resize()
	
总结：
	·求交集的两个集合必须是有序序列
	·目标容器开辟空间需要从两个容器中取小值
	·set_intersrction返回值既是交集的最后一个元素的位置

5.6.2 set_union

功能描述：
	求两个集合的并集
函数原型:
	·set_union(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);
	//求两个容器的并集
	//注意：两个容器必须是有序序列！
	//beg1 容器1开始迭代器
	//end1 容器1结束迭代器
	//beg2 容器2开始迭代器
	//end2 容器2结束迭代器
	//dest 目标容器开始迭代器
	//目标容器插入数据前先resize()
	
总结:
	·求并集的两个集合必须是有序序列
	·目标容器开辟空间需要是两个容器相加值
	·set_union返回值既是并集的最后一个元素的位置

5.6.3 set_difference

功能描述：
	求两个集合的差集
函数原型：
	·set_difference(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);
	//求两个容器的差集
	//注意：两个容器必须是有序序列！
	//beg1 容器1开始迭代器
	//end1 容器1结束迭代器
	//beg2 容器2开始迭代器
	//end2 容器2结束迭代器
	//dest 目标容器开始迭代器
	//目标容器插入数据前先resize()
	
总结:
	·求差集的两个集合必须是有序序列
	·目标容器开辟空间需要从两个容器中取较大值
	·set_difference返回值既是差集的最后一个元素的位置

erse

功能描述：
	将容器内元素进行反转
函数原型：
	·reverse(iterator beg,iterator end);
	//反转指定范围的元素
	//beg 开始迭代器
	//end 结束迭代器

5.4常用的拷贝和替换算法

学习目标：
	掌握常用的拷贝和替换算法
算法简介：
	·copy		//容器内指定范围的元素拷贝到另一个容器中
	·replace	//将容器内指定范围的旧元素修改为新元素
	·replace_if	//容器内指定范围且满足条件的元素替换为新元素
	·swap		//互换两个容器的元素

5.4.1 copy

功能描述：
	容器内指定范围的元素拷贝到另一个容器中
函数原型：
	·copy(iterator beg, iterator end, iterator dest);
	//beg 开始迭代器
	//end 结束迭代器
	//dest 目标容器开始迭代器
	
注意：
	目标容器在插入数据之前要进行resize()

5.4.2 replace

功能描述：
	将容器内指定范围的旧元素修改为新元素
函数原型：
	·replace(iterator beg, iterator end, oldvalue, newvalue);
	//将区间内旧元素替换为新元素
	//beg 开始迭代器
	//end 结束迭代器
	//oldvalue 旧元素
	//newvalue 新元素

5.4.3 replace_if

功能描述：
	将区间内满足条件的元素替换成指定元素
函数原型：
	·replace_if(iterator beg,iteraator end, _Perd, newvalue)
	//按条件替换元素，满足条件的替换成指定元素
	//beg 开始迭代器
	//end 结束迭代器
	//_Perd 谓词
	//newvalue 替换的新元素

5.4.4 swap

功能描述：
	互换两个容器的元素
函数原型：
	·swap(container c1, container c2);
	//互换两个容器的元素
	//c1 容器1
	//c2 容器2
	
注意：
	swqp交换容器时，注意交换的容器要是同种类型

5.5算术生成算法

目标：
	掌握常用的算术生成算法
注意：
	算术生产算法属于小型算法，使用时包含头文件 #include<numeric>
	
算法介绍：
	·accumulate	//计算容器元素累计总和
	·fill		//向容器中添加元素

5.5.1 accumulate

功能描述：
	计算区间内容器元素累计总和
函数原型：
	·accumulate(iterator beg, iterator end, value);
	//计算容器元素累计和
	//beg 开始迭代器
	//end 结束迭代器
	//value 起始值

5.5.2 fill

功能描述：
	向容器中填充指定的元素
函数原型;
	·fill(iterator beg, iterator end, value);
	//向容器中填充元素
	//beg 开始迭代器
	//end 结束迭代器
	//value 填充的值

5.6 常用的集合算法

目标：
	掌握常用的集合算法
算法简介：
	·set_intersection		//求两个容器的交集
	·set_union 				//求两个容器的并集
	·set_difference			//求两个容器的差集

5.6.1 set_intersection

功能描述：
	求两个容器的交集
函数原型：
	·set_intersection(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);
	//求两个容器的交集
	//注意：两个容器必须是有序序列！
	//beg1 容器1开始迭代器
	//end1 容器1结束迭代器
	//beg2 容器2开始迭代器
	//end2 容器2结束迭代器
	//dest 目标容器开始迭代器
	//目标容器插入数据前先resize()
	
总结：
	·求交集的两个集合必须是有序序列
	·目标容器开辟空间需要从两个容器中取小值
	·set_intersrction返回值既是交集的最后一个元素的位置

5.6.2 set_union

功能描述：
	求两个集合的并集
函数原型:
	·set_union(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);
	//求两个容器的并集
	//注意：两个容器必须是有序序列！
	//beg1 容器1开始迭代器
	//end1 容器1结束迭代器
	//beg2 容器2开始迭代器
	//end2 容器2结束迭代器
	//dest 目标容器开始迭代器
	//目标容器插入数据前先resize()
	
总结:
	·求并集的两个集合必须是有序序列
	·目标容器开辟空间需要是两个容器相加值
	·set_union返回值既是并集的最后一个元素的位置

5.6.3 set_difference

功能描述：
	求两个集合的差集
函数原型：
	·set_difference(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);
	//求两个容器的差集
	//注意：两个容器必须是有序序列！
	//beg1 容器1开始迭代器
	//end1 容器1结束迭代器
	//beg2 容器2开始迭代器
	//end2 容器2结束迭代器
	//dest 目标容器开始迭代器
	//目标容器插入数据前先resize()
	
总结:
	·求差集的两个集合必须是有序序列
	·目标容器开辟空间需要从两个容器中取较大值
	·set_difference返回值既是差集的最后一个元素的位置