c++学习之路

【3.19】内存分区模型
内存四区意义:
不同区域存放的数据，赋予不同的生命周期,给我们更大的灵活编程
程序exe 运行前分为 代码区和全局区；运行后分为 栈区和堆区

1.代码区:存放CPU执行的机器指令,存放函数体的二进制代码，由操作系统进行管理的
代码区是共享的，共享的目的是对于频繁被执行的程序，只需要在内存中有一份代码即可
代码区是只读的，使其只读的原因是防止程序意外地修改了它的指令
2.全局区:存放全局变量和静态变量以及常量
全局变量和静态变量（static）存放在此.
全局区还包含了常量区,字符串常量和其他常量(const修饰的全局变量)也存放在此
该区域的数据在程序结束后由操作系统释放

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

存放函数内部变量和形参

4.堆区：由程序员分配释放，要程序员不释放,程序结束时由操作系统回收
在C++中主要利用new在堆区开辟内存–>返回的是一个该类型的指针
delete释放内存，释放数组时需要delete[]+数组名

引用：
(1)一旦初始化为一个变量的别名后就不可以更改

(2)引用做函数参数：
一般函数的形参传递有两种，①值传递，不可以修改实参。②通过指针地址传递，可以修改实参。

void swap01(int a ,int b){
	int temp = a;
	a = b;
	b = temp; 
}
void swap02(int *a ,int *b){
	int temp = a;
	a = b;
	b = temp; 
}
void swap03(int &a ,int &b){
	int temp = a;
	a = b;
	b = temp; 
}


int main(){
	int a =10;
	int b =20;
//值传递
	swap01(a,b);
	cout << a<< endl; //10 值传递，没发生改变
	cout << b<< endl; //20 形参不会修饰实参
//地址传递
	swap02(&a,&b);
	cout << a<< endl; //20
	cout << b<< endl; //10 形参会修饰实参
//引用传递
	swap03(a,b);//传入a,b 接收时用a,b一样的别名接收 
	cout << a<< endl; //20 //所以在函数中对别名做修改，就是在修改原变量
	cout << b<< endl; //10 形参会修饰实参
	
	return 0;
}

(3)不要返回局部变量的引用，系统已在函数结束时释放内存
(4)如果函数的返回值是引用，这个函数可以作为左值

int& test(){
	static int a =10;//不放在栈区，放在了全局区，函数结束时内存不会被释放
	return a;//以引用的形式返回a
}
int main(){
	int &ref = test();//调用函数返回a的引用，用引用ref接到引用a
	cout << ref << endl; //10
	test() = 1000;//将1000赋值给函数返回的a的引用
	cout << ref << endl; //1000 打印a的另外引用 ref
return 0;
}

(5)引用的本质
引用的本质是一个 指针常量，有关指针的操作编译器帮我们抵挡在底层了

//发现是引用，转换为int* const ref = &a;
void func(int& ref){
	ref = 100; // ref是引用，转换为*ref = 100
}
int main(){
inta.10;
//自动转换为int* const ref = &a;指针常量是指针指向不可改，也说明为什么引用不可更改
int& ref . a;
ref = 20; //内部发现ref是引用，自动帮我们转换为: *ref = 20;
cout << "a:" << a << endl;
cout << "ref:" << ref << endl;
func(a);
return 0;
}

【3.20】
（1）函数的默认参数

int func(int a，int b = 10，int c = 10){
	return a + b +c;
}
//1．如果某个位置参数有默认值，那么从这个位置往后，从左向右，必须都要有默认值
//2．如果函数声明有默认值，函数实现的时候就不能有默认参数
int func2(int a = 10， int b = 10);//声明
int func2(int a， int b){//实现
return a + b;
}

（2）函数重载
作用:函数名可以相同，提高复用性
函数重载满足条件:
·同一个作用域下·函数名称相同
·函数参数类型不同或者个数不同或者顺序不同
注意:函数的返回值不可以作为图数重载的条件
注意事项：
引用作为重载的条件
①加不加const的引用可以作为区分

void func(int &a)

void func(const int &a)

a=10
func（a）//调用无const的，因为a是变量
func（10）//调用有const的，因为10是常量

②函数重载时如果函数有默认参数，会产生二义性

void func2(int a, int b = 10){
cout <<"func2 (int a, int b = 10)调用"<< endl;}
void func2(int a){
cout <<""func2(int a)调用”<<endl;}

func2(10)//调用时有歧义

【3.22】
类的访问权限
关键字 public 确定了类成员的访问属性。在类对象作用域内，公共成员在类的外部是可访问的。
proctected为保护权限，成员类内可以访问﹐类外不可以访问—>儿子可以访问父亲中的保护内容
私有权限private，成员类内可以访问﹐类外不可以访问—>儿子不可以访问父亲的私有内容

class与struct的区别在于默认权限不一样
class为私有private
struct为共有public

【3.23】
（1）类的构造函数是类的一种特殊的成员函数，它会在每次创建类的新对象时执行。

构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回 void。可以有参数，可以参数重载。构造函数可用于为某些成员变量设置初始值。

分类：
按参数分①有参构造
②无参构造（默认构造）
按类型分①普通构造
②拷贝构造

（2）类的析构函数是类的一种特殊的成员函数，它会在每次删除所创建的对象时执行。

析构函数的名称与类的名称是完全相同的，只是在前面加了个波浪号（~）作为前缀，它不会返回任何值，也不能带有任何参数。析构函数有助于在跳出程序（比如关闭文件、释放内存等）前释放资源。

（3）调用的方法
①括号法
②显示法
③隐式转换法

class Line{
   public:
      int getLength( void );
      Line();//无参函数构造
      Line( int len ){ // 简单的构造函数 有参构造
		len = len
	};             
      Line( const Line &obj){// 拷贝构造函数
		len = Line.len//将传入的line属性拷贝当前
};      
      ~Line();         // 析构函数
};

int main(){
//1.括号法
	Line l1;//默认构造函数调用  
	Line l2(10);//有参构造函数调用
	Line l3(l2);//拷贝构造函数调用 长度也是10
	//注意不要加小括号
	Line l1();//这句话会被认为是函数的声明，而不是创建对象语句
//2.显示法
	Line l1 = Line（10）；//有参构造函数调用 右边也称为匿名对象，当前行执行结束后系统立即回收掉
	Line l2 = Line (l1);//拷贝构造函数调用 长度也是10
	//注意不要使用拷贝构造函数 初始化匿名对象
	Line (l2)//系统认为这句等价于Line l2 与上一句一样，重定义了
//3.隐式转换法
	Line l4 = 10;//相当于写了Line l4 = Line(10)
	Line l5 = l4//;//拷贝构造函数调用 长度也是10

return 0;
}

【3.24】C++中拷贝构造函数调用时机通常有三种情况
①使用一个已经创建完毕的对象来初始化一个新对象·
②值传递的方式给函数参数传值
③以值方式返回局部对象

构造函数调用规则;
如果用户定义有参构造函数，c++不在提供默认无参构造，但是会提供默认拷贝构造(定义2，不提供1，提供3）
如果用户定义拷贝构造函数，C++不会再提供其他构造函数（定义3，不提供1,2）

【3.26】
（1）深拷贝与浅拷贝
浅拷贝:简单的赋值拷贝操惟
浅拷贝会带来堆区内存重复释放的问题：将p1拷贝给p2时就是将所有属性复制一份；但是在析构p2时在堆区的属性有可能已经被释放，再次释放时会产生错误

深拷贝:在堆区重新申请空间，进行拷贝操作
自己实现一个拷贝构造函数解决浅拷贝问题

Person(const Person &p){
cout << "Person拷贝构造函数调用"<< endl;
m_Age = p.m_Age ;
//m_Height = p.m_Height;编译器默认实现的浅拷贝 简单的等号赋值

m_Height = new int(*p.m_Height);//深拷贝操作 将要复制的属性解引用出值 new出新空间存储
}

总结：如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题

（2）初始化列表
给类中属性初始化工作
语法:构造函数():属性1(值1),属性2(值2)… {}

【3.27】
（1）类对象作为类成员
当类中成员是其他类对象时,我们称该成员为对象成员
构造的顺序是:先调用对象成员的构造，再调用本类构造
析构顺序与构造相反
（2）静态成员变量和函数
成员函数和成员变量分开存储
静态成员变量特点:
①在编译阶段分配内存，生成exe执行文件前分配
②类内声明，类外初始化
③所有对象共享同—份数据
④具有访问权限，private时类外部不可访问
⑤访问方式有两种;
其一通过对象；
其二通过类名
类名::成员变量（说明是类作用域下面的）

静态成员函数：
①所有对象共享同—份函数
②访问方式有两种;
其一通过对象；
其二通过类名
类名::成员函数（说明是类作用域下面的）
③静态成员函数可以访问静态成员变量，是因为静态成员变量属于大家的
静态成员函数不可以访问非静态成员变量，是因为调用时无法区分这个属性是谁的
④是有访问权限的
【3.31】
（1）this指针
本质是一个指针常量，指针指向不可被修改指向
隐藏在每个成员函数内部
（2）空指针访问成员函数
（3）常函数
如果不想成员函数内部变量被修改 在函数（）后面加上const
如果加了const还想被修改，加上mutable关键字
（4）常对象
在对象前加上const，说明创建的对象属性不可以被修改
但是如果常对象下面有一个mutable声明的属性，是可以被修改的
常对象只能调用常函数

（5）友元
生活中你的家有客厅(Public)，有你的卧室(Private)
厅所有来的客人都可以进去，但是你的卧室是私有的,也就是说只有你能进去
但是呢，你也可以允许你的好闺蜜好基友进去。
在程序里，有些私有属性也想让类外特殊的一些函数或者类进行访问，就需要用到友元的技术
友元的目的就是让一个函数或者类访问另-个类中私有成员

实现方式：
①全局函数做友元
②类做友元
③成员函数做友元

class Building
{
friend void goodGay(Building * building);//告诉编译器goodGay全局函数是Building类的好朋友，可以访问类中的私有内容
friend class goodGay; //告诉编译器goodGay类是Building类的好朋友，可以访问类中的私有内容
friend void GoodGay::visit2();//告诉编译器 这个成员函数是好朋友
public:
Building()
{
this->m_ SittingRoom =” 客厅";
this->m_ _BedRoom = "卧室" ;
public:
string m_ SittingRoom; //客厅
private:
string m_ BedRoom; //卧室
}

void goodGay(Building * building)//全局函数做友元
cout <<“好基友正在访问:”<< building->m_ SittingRoom << endl;
cout << "好基友正在访问:” << building->m_ _BEdRoom << endl;
}

class gooGay{//类做友元
public:
goodGay(){
building = new Building;
};//构造函数
void visit(){
cout <<“好基友正在访问:”<< building->m_ SittingRoom << endl;
cout << "好基友正在访问:” << building->m_ _BEdRoom << endl;
};//访问房间函数

void visit2(){
cout <<“好基友正在访问:”<< building->m_ SittingRoom << endl;
cout << "好基友正在访问:” << building->m_ _BEdRoom << endl;
}

private:
Building *building;

}
void test01()
{
Building b;
goodGay(&b);
int main(){
teste1();

【4.2】
运算符重载
对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型
（1）加号运算符重载

（2）左移运算符重载
【4.3】继承

继承的好处就是减少重复的代码，重复代码越多，说明越菜鸟
语法 class 子类 ： public 父类
术语 子类也称为派生类 父类也称为基类
派生类中的成员，包含两大部分:
—类是从基类继承过来的，一类是自己增加的成员。
从基类继承过过来的表现其共性，而新增的成员体现了其个性
因此父类所有的非静态成员属性都会被子类继承
继承方式：

父类私有三种继承方式都不可访问，被编译器隐藏掉了
父类属性公共继承属性不变
父类属性保护继承全变保护，私有继承全变私有

【4.4】
（1）同名非静态成员继承问题
①子类对象可以直接访问到子类中同名成员
②子类对象加作用域：：可以访问到父类同名成员
③当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数
（2）同名静态成员继承问题

【4.5】
（1）多继承语法
（2）菱形继承
利用虚继承可以解决
最一开始的类叫做虚基类
【4.5-5.5】疫情被封了
【5.5】
多态
多态分为两类
·静态多态:函数重载和运算符重载属于静态多态,复用函数名
·动态多态:派生类和虚函数实现运行时多态
静态多态和动态多态区别:
静态多态的函数地址早绑定–编译阶段确定函数地址
动态多态的函数地址晚绑定–运行阶段确定函数地址
【5.5-7.2】论文实验及写作
【7.2】多态
动态多态满足条件：
1.有继承关系
2.子类重写父类的虚函数
重写是指函数返回值类型 、函数名、 参数列表完全一致
【7.6】多态的优点
·代码组织结构清晰
·可读性强
·利于前期和后期的扩展以及维护
【7.15】纯虚函数和抽象类
在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容
因此可以将虚函数改为纯虚函数
纯虚函数语法:virtual 返回值类型 函数名(参数列表) =0 ;
当类中有了纯虚函数,这个类也称为抽象类
抽象类特点:
①抽象类无法实例化对象
②子类必须重写抽象类中的纯虚函数，否则也属于抽象类
【7.19】虚析构和纯虚析构
问题：多态使用时，如果子类中有属性开辟到堆区(new)，那么父类指针在释放时无法调用到子类的析构代码
解决方式:将父类中的析构函数改为虚析构(+virtual)或者纯虚析构

虚析构和纯虚析构共性:
·可以解决父类指针释放子类对象·都需要有具体的函数实现
虚析构和纯虚析构区别:
·如果是纯虚析构，该类属于抽象类,无法实例化对象

文件操作
写文件步骤如下:
1.包含头文件
#include
2.创建流对象
ofstream ofs;
3.打开文件
ofs.open(“文件路径”.,打开方式);
4.写数据
ofs <<“写入的数据”;
5.关闭文件
ofs.close();
读文件步骤如下:
1.包含头文件
#include
2.创建流对象
ifstream ifs;
3.打开文件并判断文件是否打开成功ifs.open(“文件路径".,打开方式);
4.读数据
四种方式读取
5.关闭文件ifs.close();
【7.21】模板
.C++另一种编程思想称为泛型编程，主要利用的技术就是模板·
C++提供两种模板机制:函数模板和类模板

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

语法:
template
函数声明或定义

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

//交换整型函数
void swapInt( int& a,int& b){
int temp = a;a - b;b = temp;
//交换浮点型函数
void swapDouble(doue& a，double& b) {
double temp = a;a = b;b - temp;
//利用模板提供通用的交换函数
template<typename T>
void mySwap(T&a，T& b){
T temp = a;
a = b;
b = temp;
//使用模板
  //自动类型推导
int a,b=10,20
mySwap(a,b)
  //显示指定类型
mySwap<int>(a,b)

注意事项：
自动类型推导，必须推导出一致的数据类型T,才可以使用模板
必须要确定出T的数据类型，才可以使用
【7.22】
普通函数与函数模板区别:
·普通函数调用时可以发生自动类型转换（隐式类型转换)
·函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换·
如果利用显示指定类型的方式，可以发生隐式类型转换
调用规则如下:
1.如果函数模板和普通函数都可以实现，优先调用普通函数2.可以通过空模板参数列表来强制调用函数模板
3.函数模板也可以发生重载
4.如果函数模板可以产生更好的匹配,优先调用函数模板
总结:既然提供了函数模板，最好就不要提供普通函数，否则容易出现二义性
【7.23】模板的局限性

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

类模板：
类模板作用:
·建立一个通用类，类中的成员数据类型可以不具体制定，用一个虚拟的类型来代表。

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

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

template<class NameType, class AgeType>
class Person
{
public:
Person (NameType name，AgeType age=int)//在模板参数列表设置默认参数
{
this->m_Name = name ;
this->m_Age = age ;
}}

【7.25】
类模板与继承

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

类模板分文件编写
问题:
·类模板中成员函数创建时机是在调用阶段，导致分文件编写时链接不到
解决:
·解决方式1:直接包含.cpp源文件
·解决方式2∶将声明和实现写到同一个文件中，并更改后缀名为.hpp，hpp是约定的名称，并不是强制
总结:主流的解决方式是第二种，将类模板成员函数写到一起，并将后缀名改为.hpp
【7.26】
STL初识
STL的诞生
·长久以来，软件界一直希望建立一种可重复利用的东西。C++的面向对象和泛型编程思想，目的就是复用性的提升
·大多情况下，数据结构和算法都未能有一套标准,导致被迫从事大量重复工作
为了建立数据结构和算法的一套标准,诞生了STL
STL基本概念
. STL(Standard Template Library,标准模板库)
.STL从广义上分为:容器(container)算法(algorithm)送代器(iterator)。容器和算法之间通过迭代器进行无缝连接。
. STL几乎所有的代码都采用了模板类或者模板函数
STL大体分为六大组件，分别是:容器、算法、迭代器、仿函数、适配器(配接器)．空间配置器

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

1.容器:置物之所也
STL容器就是将运用最广泛的—些数据结构实现出来常用的数据结构:数组,链表,树,栈,队列,集合,映射表等这些容器分为序列式容器和关联式容器两种:
序列式容器:强调值的排序，序列式容器中的每个元素均有固定的位置。关联式容器:二叉树结构，各元素之间没有严格的物理上的顺序关系
算法:问题之解法也
有限的步骤，解决逻辑或数学上的问题，这一门学科我们叫做算法(Algorithms)算法分为:质变算法和非质变算法。
质变算法:是指运算过程中会更改区间内的元素的内容。例如拷贝，替换，删除等等
非质变算法:是指运算过程中不会更改区间内的元素内容，例如查找、计数、遍历、寻找极值等等

2.算法:问题之解法也
有限的步骤，解决逻辑或数学上的问题，这一门学科我们叫做算法(Algorithms)I算法分为:质变算法和非质变算法。
质变算法:是指运算过程中会更改区间内的元素的内容。例如拷贝，替换，删除等等
非质变算法:是指运算过程中不会更改区间内的元素内容，例如查找、计数、遍历、寻找极值等等

3.迭代器:容器和算法之间粘合剂
提供一种方法，使之能够依序寻访某个容器所含的各个元素，而又无需暴露该容器的内部表示方式。每个容器都有自己专属的迭代器

【7.28】vector基本概念
功能:
vector数据结构和数组非常相似，也称为单端数组
vector与普通数组区别:
·不同之处在于数组是静态空间，而vectorp以动态扩展
动态扩展:
·并不是在原空间之后续接新空间，而是找更大的内存空间，然后将原数据拷贝新空间，释放原空间

语法

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

第二种遍历方式:
for (vector : :iterator it = v.begin(); it != v.end( ); it++) {
cout <<*it << endl;
}

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

Vector中嵌套容器
语法vector<vector>v；
【7.29】

对vector容量和大小操作函数原型:
empty();
//判断容器是否为空
capacity();
//容器的容量
size();
/返回容器中元素的个数
resize(int num) ;
//重新指定容器的长度为num，若容器变长，则以默认值填充新位置。//如果容器变短，则末尾超出容器长度的元素被删除。
resize(int num，elem);//重新指定容器的长度为num，若容器变长，则以elem值填充新位置。
//如果容器变短，则末尾超出容器长度的元素被删除
· 对vector容器进行插入、删除操作
函数原型;
push_back(ele);
//尾部插入元素ele
pop_back();
//删除最后一个元素
insert(const_iterator pos, ele);
//迭代器指向位置pos插入元素ele
insert(const_iterator pos, int count,ele);//迭代器指向位置pos插入count个元素eleerase(const_iterator pos);
//册除迭代器指向的元素
erase(const_iterator start, const_iterator end);//删除迭代器从start到end之间的元素
clear();册除容器中所有元素
功能描述:
· 对vector中的数据的存取操作
函数原型:
at(int idx);1/返回索引idx所指的数据
operator[];//返回索引idx所指的数据
front();
//返回容器中第一个数据元素
back();
/返回容器中最后一个数据元素

swap(vector)//交换两个容器
当开辟一个很大内存空间后，重新resize()结果是大小改变了，容量没有改变
因此为了节省内存空间，我们使用swap收缩内存空间
语句：vector(v).swap(v)
首先vector(v)创造了一个比较小的匿名对象（会自动回收空间）
然后通过swap语句交换空间

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

【7.30】

本质:
. string是C++风格的字符串，而string本质上是一个类string和char区别:
. c 语言中char是一个指针
. string是一个类，类内部封装了char*，管理这个字符串，是一个char型的容器。
特点:
string类内部封装了很多成员方法I
例如:查找find，拷贝copy，删除delete替换replace，插入insert
string管理char所分配的内存，不用担心复制越界和取值越界等，由类内部进行负责

构造函数原型:
string();
//创建一个空的字符串例如: string str;
string( const char* s);
//使用字符串s初始化
string(const string& str);//使用一个string对象初始化另一个string对象string(int n,char c);
//使用n个字符c初始化

赋值的函数原型:
string& operator=( const char* s );
llchar*类型字符串赋值给当前的字符串
string& operator=( const string &s ) ;
l/把字符串s赋给当前的字符串
string& operator=( char c);
1/字符赋值给当前的字符串
string& assign(const char *s);
1/把字符串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+=( 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个字符连接到字符串结尾

功能描述:
·查找:查找指定字符串是否存在·
替换:在指定的位置替换字符串函数原型:
int find(const string&str， int pos=0) const;//查找str第一次出现位置,从pos开始查找
int find(const char* s, int pos=e) const;//查找s第一次出现位置,从pos开始查找
int find(const char* s, int pos, int n) const;//从pos位置查找s的前n个字符第一次位置
int find(const char c, int pos = e) const;
//查找字符c第一次出现位置
int rfind(const string& str, int pos = npos) const;
//查找str最后一次位置(从右往左查找）,从pos开始查找
int rfind(const char* s， int pos = npos) const;
//查找s最后一次出现位置,从pos开始查找
int rfind(const char* s, int pos, int n) const;
//从pos查找s的前n个字符最后一次位置
int rfind(const char c, int pos=e) const;
//查找字符c最后一次出现位置
string& replace(int pos, int n, const string& str);
//替换从pos开始n个字符为字符串str
string& replace(int pos, int n,const char* s);
l/替换从pos开始的n个字符为字符串s

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

string中单个字符存取方式有两种
char& operator[](int n); //通过[]方式取字符
char& at(int n);
//通过at方法获取字符

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

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

【8.4】
deque()容器

构造函数原型:
deque<T> deqT;
//默认构造形式
deque( beg, end);
!/构造函数将[beg, end)区间中的元素拷贝给本身。
deque(n,elem);
//构造函数将n个elem拷贝给本身。
deque( const deque &deq);//拷贝构造函数
【8.6】
赋值函数原型:
deque& operator=(const deque &deq);
//重载等号操作符
assign(beg, end ) ;
Il将[beg, end)区间中的数据拷贝赋值给本身。
assign(n,elem);
//将n个elem拷贝赋值给本身。

对deque容器的大小进行操作
函数原型:
deque.empty();
//判断容器是否为空
deque.size( );
//返回容器中元素的个数
deque.resize(num) ;
1/重新指定容器的长度为num,若容器变长，则以默认值填充新位置。//如果容器变短，则末尾超出容器长度的元素被删除。
deque.resize(num,elem);
//重新指定容器的长度为num,若容器变长，则以elem值填充新位置。//如果容器变短，则末尾超出容器长度的元素被删除。
【8.7】
向deque容器中插入和删除数据
函数原型:
两端插入操作:
push_back(elem);
/在容器尾部添加一个数据
push_front(elem);
//在容器头部插入一个数据
pop_back() ;
//册除容器最后一个数据
pop_front( );
//删除容器第一个数据
指定位置操作:
insert(pos,elem);
ll在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位置的数据，返回下一个数据的位置。
【8.8】
对deque中的数据的存取操作
函数原型:
at(int idx);//返回索引idx所指的数据
operator[]//返回索引idx所指的数据
front();//返回容器中第一个数据元素
back();//返回容器中最后一个数据元素
·利用算法实现对deque容器进行排序
sort(iterator beg, iterator end)l/对beg和end区间内元素进行排序

不允许有遍历行为
【8.10】
构造函数:
stack stk;
//stack采用模板类实现, stack对象的默认构造形式
stack(const stack &stk);//拷贝构造函数
赋值操作:
stack& operator=(const stack &stk );//重载等号操作符
数据存取:
push(elem);//向栈顶添加元素
pop();//从栈顶移除第一个元素
top();//返回栈顶元素
大小操作:
empty();//判断堆栈是否为空
size();//返回栈的大小

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

链表

【8.16】

list<T> lst;
l/list采用采用模板类实现,对象的默认构造形式:
list(beg,end) ;
//构造函数将[beg, end)区间中的元素拷贝给本身。
. list(n,elem);
//构造函数将n个elem拷贝给本身。
. list(const list &lst);
//拷贝构造函数。
给list容器进行赋值，以及交换list容器函数原型:
assign(beg,end) ;
1/将[beg, end)区间中的数据拷贝赋值给本身。
assign(n,elem);
l将n个elem拷贝赋值给本身。
list& operator=( const list &lst);
//重载等号操作符
swap(lst);
//将lst与本身的元素互换。
· 对list容器的大小进行操作
函数原型:
size();
1/返回容器中元素的个数
empty();
I/判断容器是否为空
resize(num);
//重新指定容器的长度为num，若容器变长，则以默认值填充新位置。//如果容器变短，则末尾超出容器长度的元素被删除。
resize(num，elem);
I/重新指定容器的长度为num，若容器变长，则以elem值填充新位置。//如果容器变短，则末尾超出容器长度的元素被删除。

功能描述:
●对list容器进行数据的插入和删除
函数原型:
●push_ back(elem);//在容器尾部加入一个元素
●pop_ bacx:/:/删除容器中最后一个元素
●push_ front(elem);//在容器开头插入一个元素
●pop front);//从容器开头移除第一个元素
●insert(pos,elem)//在pos位置插elem元素的拷贝，返回新数据的位置。
●insert(pos,n,elem)//在pos位置插入n个elem数据， 无返回值。
●insert(pos,beg,end;//在pos位置插入beg,end)区间的数据，无返回值。
●clear()//移除容器的所有数据
●erase(beg,end;//删除[beg,end)区间的数据， 返回下一个数据的位置。
●erase(pos);//删除pos位置的数据， 返回下一个数据的位置。
●remove(elem);/删除容器中所有与elem值匹配的元素。

●对list容器中数据进行存取
函数原型:
●front();//返回第一个元素。
●back();//返回最后一个元素。

功能描述:
●将容器中的元素反转，以及将容器中的数据进行排序
函数原型:
●reverse(); //反转链表
●sort();//链表排序