爆肝一个月手写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.构造函数，没有返回值也不写void2.函数名称与类名相同3.构造函数可以有参数，因此可以发生重载4.程序在调用对象的时候会自动调用构造，无须手动调用，而且只会调用一次析构函数语法：~类名（）{}1.析构函数没有返回值也不写void2.函数名称与类名相同，在名称前加上符号~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::in	为读文件而打开文件
ios::out	为写文件而打开文件
ios::ate	初始位置：文件尾
ios::app	追加方式写文件
ios::trunc	如果文件存在先删除，再创建
ios::binary	二进制方式

注意：文件打开方式可以配合使用，利用| 操作符
例如：用二进制方式写文件 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

迭代器种类：

种类	功能	支持运算
输入迭代器	对数据的只读访问	只读，支持++、==、！=
输出迭代器	对数据的只写访问	只写，支持++
前向迭代器	读写操作，并能向前推进迭代器	读写，支持++、==、！=
双向迭代器	读写操作，并能向前向后操作	读写，支持++、–
随机访问迭代器	读写操作，可以以跳跃的方式访问任意数据，功能最强的迭代器	读写，支持++、–、[n]、-n、<、<=、>、>=

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，插入insertstring管理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个字符为字符串srfind和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())区间中的元素拷贝给v1vector<T>v2(n, elem);  //构造函数将n个elem拷贝给v2vector<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);  //尾部插入元素elepop_back();     //删除最后一个元素insert(const_itreator pos, ele);  //迭代器向位置pos插入元素eleinsert(const_itreator pos, int count,ele);  //迭代器向位置pos插入元素count个eleerase(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返回值既是差集的最后一个元素的位置