C++学习记录

C++核心编程

C++中面向对象的三大特性是：封装，继承，多态；
接下来慢慢说；

封装

C++和C语言最大的不同就是面向对象编程思想，而封装就是面向对象编程很重要的一部分；
C++讲究万物皆可对象，对象到底是什么？和类又有什么关系呢？

举个例子：人类就涵盖了世界上各种各样不同的人，所以人类就是一个类，这个类的属性可以有身高、体重、年龄、肤色、性别等等，他们都可能会走路、做饭、睡觉等行为；而每一个人都是这个类的对象；类就是将一个对象的属性和行为的综合；

类是对象的抽象和概括，而对象是类的具体和实例

C++用class定义一个类，类中有三部分：
1、属性
2、行为
3、访问权限(public,protected,private)

语法：
class Name
{
访问权限：
属性
行为
};

公共权限public：类内类外都可以访问
保护权限protected：类内可以访问类外不可以访问（继承中的派生类可以访问基类）
私有权限private：类内可以访问类外不可以访问（继承中的派生类不可以访问基类）

---

private是完全私有的，只有自己可以访问，派生类和外部都不可以访问
protected是受保护的，只有派生类可以访问，外部不能访问

C++就是这样将一个对象的属性和行为作为个整体封装成为了一个类；

需要注意的是，如果声明为private类型，则在主函数中主要通过 对象.变量 的方式直接访问的话就会报错，原因private类型的变量是私有类型，不允许外部访问。

对于想保护但又想控制的私有变量，我们通常将其声明为private类型，然后同时定义一个public类型的专门赋值的方法（如赋值函数），由于内部成员可以访问private声明的变量，我们就可以在外部通过这个public的方法来间接控制这些私有的成员，来起到封装、保护的效果，而这个public类型的方法，也称之为这个类的一个外部接口。

class和struct有什么区别呢？
class默认权限是私有的
struct默认权限是公共的

对象特征

构造函数和析构函数

当你创建了一个类之后类内会自动生成四个函数：

默认构造函数（无参，函数体为空）
默认拷贝构造函数，对属性进行值拷贝(浅拷贝)
默认析构函数（无参，函数体为空）
赋值运算符 operator=,对属性进行值拷贝(浅拷贝)

先只说构造函数和析构函数；

构造函数
构造函数相当于对类内的属性进行初始化的一个函数；
特征：
1函数名和类名相同，且无返回值；
2构造函数可以有参数，且可以发生重载；
3创建对象的时候，构造函数会 自动 调用，且只调用一次（若用类定义了指针或引用，则不会调用析构函数，因为都没有创建新对象）

因为构造函数可以有参数且可以重载，所以构造函数分为以下三类：
1，默认（无参）构造函数
2，有参构造函数：自定义参数对属性进行初始化赋值
3，拷贝构造函数：将同类的属性拷贝到自己身上

调用过程也有三种方式：（以Person类为例）
1，括号法：
Person p;//默认构造函数
Person p(10,100);//有参构造函数
Person p(p1)//拷贝构造函数

注意事项：
调用默认构造函数的时候不要加()
例：Person p();
因为该代码编译器会认为是一个函数声明，不会认为在创建对象

2，显示法
Person p;
Person p=Person(10,100);
Person p=Person(p1);

这个方法有一种叫作匿名对象的声明方法，即不创建对象，只调用构造函数；
匿名对象：
Person (10);//匿名对象，特点：当前执行任务结果后，系统会立即回收匿名对象(正常的是函数结束后才会收)

注意事项：不要用拷贝构造函数初始化匿名对象，编译器会认为Person (p3)=Person p3

3，隐式转换法
Person p;
Person p=(10,100);
Person p=p1;

就是相当于将显示法的第二个Person给去掉了；

这三种方法都可以使用，但是最好还是使用括号法，写起来简单，看上去清楚；

构造函数调用规则
因为构造函数是编译器自己提供的，而我们也可以自己写专属的构造函数，则当我们写构造函数的时候有以下规则：

1，如果用户定义了有参构造函数，那么编译器将不再提供默认构造函数，但还会提供默认拷贝构造函数；
2，如果用户定义了拷贝构造函数，那么编译器将不会再提供其他构造函数；

所以如果你定义了拷贝构造函数，但是还需要默认构造函数和有参构造函数，那怎么办？很简单，自己再定义一下默认构造函数和有参构造函数就行了，可以多个构造函数存在一个类中；

析构函数

析构函数就不像构造函数有那么多规则，它就执行一个清理操作，直接看看特点吧；
析构函数：
1，函数名和类名相同，但是需要在前面加一个~符号，且没有返回值；
2，析构函数没有参数，且不会发生重载；
3，对象在销毁前会 自动 调用析构函数，且只调用一次

一个类中只能有一个析构函数，不能重载，但是可以为虚函数（多态中会介绍到）；

这就是析构函数了，它也可以自己声明，但是一般直接用编译器提供的就好，反正它也没有什么操作；

深拷贝和浅拷贝
(在+号运算符重载时也会出现深拷贝与浅拷贝)
我们知道一个类中编译器会自己给你提供一个拷贝构造函数，有时候为什么还要自己写一个新的呢？这就涉及到了深拷贝和浅拷贝；
有时候面试有时候会问到深拷贝和浅拷贝，是一个坑；
浅拷贝：简单的赋值拷贝操作
深拷贝：在堆区重新申请空间，进行拷贝操作

编译器提供的默认构造函数进行的拷贝是一个浅拷贝，是一个直接的赋值操作，如果给你赋值的对象A内存是在堆区开辟为S，那么你新初始化的对象B也指向了这一块内存(S)，两个指针都将指向这一块内存(S)，这就会出现一问题，就是一旦你这个新对象B(delete)释放这块内存(S)后，那么赋值的对象A这块内存(S)也不存在了，当它想释放这块内存(S)时已经什么都没有了，这就出现了二次释放；

解决办法就是自己创建一个拷贝构造函数，当拷贝这一块堆区内存时，进行深拷贝，即在堆区再开辟一块新的空间来存放赋值对象的东西，这样新对象的内存和赋值对象的内存就是两码事，互不干扰；

简单说就是如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题；

this指针

说实话这个this指针由于我初学c++，并没有理解太多用途，就简单介绍一下；
每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用一块代码
那么问题是：这一块代码是如何区分那个对象调用自己的呢？
c++通过提供特殊的对象指针，this指针，解决上述问题。this指针指向被调用的成员函数所属的对象；
为什么说它特殊？因为只要定义一个类，系统就会预定义个名字叫做this名且指向当前对象的指针。虽然我们看不到但却可以使用它。

this指针是隐含每一个非静态成员函数内的一种指针

this指针不需要定义，直接使用即可

this指针的用途：
当形参和成员变量同名时，可用this指针来区分(这是编程的不规范的解决方法)
在类的非静态成员函数中返回对象本身，可使用return *this

当一个对象调用其成员函数的时候，即便程序中有多个该类的对象，但成员函数的代码也仅有一份，所以为了区分它们是哪个对象调用的成员函数，编译器也是转化成this->成员函数这种形式来使用的。

友元

友元用途就是当你想通过一个函数或者类访问另一个类中的私有权限内容时提供的一种方法；

可以理解为当定义友元后就成了好盆友，那么私有权限就可以访问了；
以下是几个形式：（在函数或类前面加friend声明友元）

全局函数作友元：

class Gay
{
  friend void visit();
  //告诉编译器visit全局函数是Gay类的好朋友，可以访问类中的私有内容
private:
   int age;
};
void visit()
{
   Gay g;
   g.age;//定义友元后就可以访问Gay中的私有权限内容了；
}

友元类：

class Gay
{
  friend class Gay2;
  /告诉编译器Gay2类是Gay类的好朋友，可以访问到Gay类中私有内容
private:
  int age;
};

class Gay2
{
private:
  Gay g;
public:
  void visit()
  {
     g.age;//定义友元后可以访问私有成员
  }
};

成员函数作友元：

class Gay
{
  friend void Gay2::visit;
  /告诉编译器成员函数visit是Gay类的好朋友，可以访问到Gay类中私有内容
private:
  int age;
};

class Gay2
{
private:
  Gay g;
public:
  void visit()
  {
     g.age;//定义友元后可以访问私有成员
  }
};

友元的优缺点
优点：更方便快捷的访问类内的私有成员
缺点：打破了C++中的封装思想

运算符重载

C++提供了运算符重载，可以使代码写起来更方便，有更多可能性；
语法：返回值类型 operator运算符号(形参)

几种运算符重载（void为例）：

void operator+()//+号
void operator=()//赋值运算符
void operator==()//关系运算符
void operator<<(ostream cout,形参)//左移运算符
//该运算符重载若想实现cout<<就只能写为全局函数，若写在类中就只能为<<cout这种形式
//ostream时cout的数据类型，（如cin为istream）
void operator()()//函数调用运算符
void operator++()//++a
void operator++(int)//a++，这两个都是递增运算符，
//++在后面的需要在括号内写一个int占位参数

运算符重载非常灵活，这几种只是一个例子；

继承

继承是面向对象的另一重要部分，继承，可以理解为一个类继承另一个类中的属性和行为然后便可以使用它；
继承的好处：可以减少重复的代码

语法： class A（子类） : public B（父类）;

专业术语：
A 类称为子类 或 派生类
B 类称为父类 或 基类

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

继承方式
继承有三种方式：
三种方式继承父类：
1公共继承：
子类公共继承后可访问父类中的 公共权限和保护权限，不可以访问父类中私有权限
2保护继承
子类保护继承后父类中的公共权限会变成保护权限，不可以访问父类中私有权限
3私有继承
子类私有继承后父类中的公共权限和保护权限都会变成私有权限，不可以访问父类中私有权限

这个说起来不清楚，上一张某马视频里的截图：

看懂了这个图那么继承方式就会理解了；

多继承·：不建议使用就不说了；
——————————————————————————————————————————————
继承中同名成员处理：尽量不要出现子类和父类出现同名成员的情况，如果出现了，子类会
子类会隐藏父类中 所有 版本的同名成员(包括重名的重载函数)，这时候想通过子类对象调用父类，需要加父类的作用域
如：
子类Son出现了和父类Base重名的成员age；
Son s;
s.age;//子类的age
s.Base::age//父类的age

多态

多态是面向对象编程的一大重要部分（前面已经说了封装和继承），多态是基于继承的其他操作，先举个例子：
动物这个类可以分为猫类，狗类，鸟类等等；而猫类又可以分为加菲猫类，缅因猫类，虎皮猫类等等，狗类分为哈巴狗类，吉娃娃类，哈士奇类等等，鸟类…………；

在面向对象程序设计中，多态指同样的方法被不同对象执行时会有不同的执行效果。

我们希望传入什么对象，那么就调用什么对象的函数
如果函数地址在编译阶段就能确定，那么静态联编
如果函数地址在运行阶段才能确定，就是动态联编

静态多态的函数地址早绑定 - 编译阶段确定函数地址
动态多态的函数地址晚绑定 - 运行阶段确定函数地址

多态满足条件：
1、有继承关系
2、子类重写父类中的虚函数（重写：函数返回值类型 函数名 参数列表 完全一致称为重写）
多态使用方式：
父类指针或引用指向子类对象（父类声明一个指针，然后通过该指针动态分配子类的内存）

纯虚函数
在建立了父类虚函数后使用中我们会发现，我们从不会调用父类的虚函数，在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容，所以我们可以把虚函数改为纯虚函数；

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

当这个类有了纯虚函数，那么这个类就称为抽象类

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

虚析构和纯虚析构
当我们使用多态时，如果子类有属性开辟到堆区，则会出现一个问题，就是delete释放父类指针的时候无法调用到子类的析构函数代码；
这时候只需要一个操作，就是将父类中的析构函数写为虚析构函数或纯虚析构函数；

虚析构和纯虚析构共性：
1.都可以解决父类指针释放子类对象
2.都需要有具体的函数实现（即重写一遍）

虚析构和纯虚析构区别：
如果写了纯虚析构，那么该类就会为抽象类，无法实例化对象

虚析构语法

virtual ~类名(){}

纯虚析构语法

virtual ~类名()=0
然后在类外再写实现：
类名::~类名(){}

文件操作

为什么需要文件操作？因为程序运行时产生的数据都是临时数据，程序一旦运行结束就会被释放，所以可以通过文件将数据持久化；

C++中对文件操作需要包含头文件 < fstream >

文件类型分为两种：
1，文本文件：文件以文本的ASCLL码形式存储在计算机中；
2，二进制文件：文件以文本的二进制形式存储在计算机中，用户一般不能直接读懂；

操作文件三大类：
1，ofstream：写操作
2，ifstream：读操作
3，fstream：读写操作

文本文件：

写文件步骤如下：

1，包含头文件
#include

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

读文件
读文件与写文件步骤相似，但是读取方式相对于比较多
读文件步骤如下：
1，包含头文件
#include

2，创建流对象
ifstream ifs;

3，打开文件并判断文件是否打开成功
ifs.open(“文件路径”,打开方式);

4，读数据
四种方式读取
ps：用string的方法读取方便

void text() {
    ifstream ifs;
    ifs.open("text2.txt", ios :: in);
    if(!ifs.is_open()) {
        cout<< "文件打开失败" <<endl;
        return ;
    }
    //定义一个string类来一行一行读取ifs所打开的文件；
    string buf;
    while (getline(ifs, buf)) {
        cout << buf <<endl;
    }
    ifs.close();
}

5，关闭文件
ifs.close();

二进制文件

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

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

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

C++提高编程

这里主要针对的是泛型技术和STL的学习；

模版

模版是什么呢？我们在平时制作ptt过程中，软件内部常常会提供有一些已经包装好的精美的ptt模版，我们只需要选择一个好看的，在相应的位置做出改动就可以得到属于自己的ptt；
这就是ptt模版；
c++中的模版也是一样，如果我们写了一个输出函数Print，我们可以定义函数形参为int，char，string等，但是如果我们想用它输出类定义的对象又改该怎么办？这是就会想，如果我们能指定这个函数输出什么类型数据它就可以输出什么类型数据就好了，这就诞生了模版；

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

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

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

注：我们虽然学习模版，但是并不是一定要求我们要写出完美的模版，我们只需要了解模版的基础操作，从而会用模版，在以后的STL中可以用好c++提供的模版；

函数模版

函数模板作用：
建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表。
这就像开始举的Print函数的例子，我们想通过该函数实现任意数据类型的输出，这就需要一个函数模版；

语法： template< typename T >函数声明或定义(这里的typename可以替换为class，都一样)
template：模版创建声明
typename/class：其后面的符号是一种数据类型
T：通用的数据类型，可以是任意字母，一般使用大写

使用函数模板有两种方式：

template<class T>
void swap(T&a,T&b)
{
   T temp;
   temp=a;
   a=b;
   b=temp;
}

自动类型推导

int a=100,b=10;
swap(a,b)//自动类型推导，必须推导出一致的数据类型T,才可以使用

显示指定类型

int a=100,b=10;
swap<int>(a,b)

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

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

建议：使用指定类型转换，清晰明了，且后面的类模版必须声明指定类型

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

语法： template
类

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

对于类模版还有许多细节性的东西，这里就不细写了，重心还是放在之后的STL上；

STL

vector容器

功能：vector的数据结构和数组特别相似，称为单端数组
不同之处是数组是静态空间，而vector的空间可以动态扩展；

动态扩展：
1，当开辟空间满的时候，仍需要向里面添加数据，这时就会发生动态扩展，并不是在原空间之后续接新空间，而是创造一个新的更大的空间，然后把小空间内的所有数据拷贝过去，再把小空间释放；
2，vector容器的迭代器时支持随机访问的迭代器。

vector部分用法（只记录常用）：
构造函数：

vector<T>v //默认构造函数
vector<T>v2 (v1.begin,v1.end)//将v1的begin到end区间内的数据拷贝到v2上（注意end是最后一个数据的后一个位置）
vector<T>v(v1) //拷贝构造函数，将v1的数据拷贝给v
vector<T>v(10,100) //有参构造函数，将10个100作为v的初始化

成员函数和重载的运算符

**加粗样式**
1，赋值操作：
//以下两个是将v2的值赋给v1
v1=v2 
//vector& operator=(const vector &vec);重载等号操作符
v2.assign(v1.begin(),v1.end())
//assign(begin, end); //将[begin, end)区间中的数据拷贝赋值给本身。
v2.assign(n,elem)
//assign(n, elem); //将n个elem拷贝赋值给本身。
operator=更简单方便，可根据实际情况使用；

2，容量和大小：
v.empty()
//判断容器v是否为空
int c=v.capacity()
//计算容器v的容量，返回值为容量大小c
int s=v.size()
//计算容器c的元素个数，返回值为元素个数s
v.resize(int num)
//重新指定容器长度为num，如果num大于容器容量，则以默认填充新位置，如果容器变小，则末尾超出部分的元素删除；
v.resize(int num,elem)
//重新指定容器长度为num（若num小于实际容量并不会改变容量大小），如果num大于容器容量，则以elem填充新位置，如果容器变小，则末尾超出部分的元素删除；
注意⚠️：这里容量(capacity)和容器的元素个数(size)不是一个概念，容量是大于等于元素个数的，编译器会根据你增加的元素个数多少自动分配容量大小；

3，插入和删除：
v.push_back(elem)
//尾部插入元素elem
v.pop_back()
//删除尾部元素
v.insert(v.begin()+n,elem)
//在v的n的位置插入元素elem；（必须有v.begin()）
//insert(const_iterator pos, elem);迭代器指向位置pos插入元素elem
v.insert(v.begin()+n,int count,elem)
//在v的n的位置插入count个元素elem；
//insert(const_iterator pos, int count,elem);迭代器指向位置pos插入count个元素elem
v.erase(v.begin()+n)
//删除n位置的元素
//erase(const_iterator pos); //删除迭代器指向的元素
v.clear()
//删除容器中所有元素
注意⚠️：insert和erase都是位置迭代器

数据存储：
v[n]
//v的第n个数据；operator[]; 返回索引idx所指的数据
v.at(n)
//v的第n个数据；at(int idx); 返回索引idx所指的数据
int f=v.front()
//将容器的第一个值赋给f，即返回v的第一个数据
int b=v.back()
//将容器的最后一个值赋给b，即返回b的最后一个数据

互换容器：
v.swap(v1)
//将v1的数据元素和v的数据元素互换（⚠️交换的是所有容量，即空间）
swap又一个巧妙用法：
❗️可以收缩内存：
vector<int>(v).swap(v)
这个可以看作三部分
1，vector<int>//创建了一个匿名对象
2，（v）//将v的所有数据元素赋给匿名对象
3，swap(v)//交换匿名对象和v的数据（容量）
⚠️收缩内存有什么用呢？当我们出现容量远远大于数据元素个数时，会造成空间的浪费，这时我们就可以用这个方法收缩内存，匿名对象在执行完这一行后就会自动释放

预留空间：
v.reserve(int len)
//给容器v预留len大小的空间
//容器预留len个元素长度，预留位置不初始化，元素不可访问。
⚠️如果数据量较大，可以一开始利用reserve预留空间，减少vector在动态扩展容量时的扩展次数

string容器
在c语言中，我们可以通过一个字符数组定义字符串，但是可能不小心该数组空间就不够用了，非常麻烦；c++中提供了一种新的定义字符串的方式，那就是string容器；
string本质上是一个类，封装了char*，是一个char型的容器；
string管理char所分配的内存，不用担心复制越界和取值越界等，由类内部进行负责
构造函数

string s();
//string(); 创建一个空的字符串 例如: string str;
string s("hello");
//string(const char* s); 使用字符串s初始化
string s1(s);
//string(const string& str); 使用一个string对象初始化另一个string对象
string s2(10,'a');
//string(int n, char c); 使用n个字符c初始化
⚠️这几种初始化方法不分好坏，可根据实际情况使用

成员函数

1，赋值操作
string s1="hello";
//string& operator=(const char* s); char*类型字符串 赋值给当前的字符串
string s2=s1;
//string& operator=(const string &s); 把字符串s赋给当前的字符串
string s3='a';
//string& operator=(char c); 字符赋值给当前的字符串
string s4.assign("world");
//string& assign(const char *s); 把字符串s赋给当前的字符串
string s5.assign(s4);
//string& assign(const string &s); 把字符串s赋给当前字符串
string s6.assign("hello world",5);
//string& assign(const char *s, int n); 把字符串s的前n个字符赋给当前的字符串
string s7.assign(10,'a');
//string& assign(int n, char c); 用n个字符c赋给当前字符串
⚠️operator= 这种方式是比较实用的;

2,字符串拼接
string s1="I";
s1+="Love";
//string& operator+=(const char* str); 重载+=操作符
s1+=':';
//string& operator+=(const char c); 重载+=操作符
string s2;
s2="you";
s1+=s2;
//string& operator+=(const string& str); 重载+=操作符
s1.append("forever");
//string& append(const char *s); 把字符串s连接到当前字符串结尾
s1.append("and I",3);
//string& append(const char *s, int n); 把字符串s的前n个字符连接到当前字符串结尾
s1.append(s2);
//string& append(const string &s); 同operator+=(const string& str)
s1.append(s2,2,1);
//string& append(const string &s, int pos, int n);字符串s中从pos开始的n个字符连接到字符串结尾
⚠️会灵活使用就行；
3，查找和替换（只写几个常用的）
string s1="hello world";
int pos=s1.find("world");
//int find(const string& str, int pos = 0) const; 查找str第一次出现位置,返回值为pos
int pos=s1.rfind("world");
//rfind是从右向左查找，一般还是用find
s1.replace(6,5,"beautiful girl");
//将第6个位置后的5个字符替换为"beautiful girl"
//string& replace(int pos, int n, const string& str); 替换从pos开始n个字符为字符串str
⚠️find找到字符串后返回查找的第一个字符位置，找不到返回-1，
⚠️replace在替换时，要指定从哪个位置起，多少个字符，替换成什么样的字符串
4，字符串比较
string s1("hello");
string s2("world");
s1.compare(s);
//int compare(const string &s) const; 与字符串s比较
//= 返回 0,>返回 1,<返回 -1
最方便方法：直接比较，这是重载的运算符
s1>s2;
s1<s2;
s1==s2;
⚠️字符串对比主要是用于比较两个字符串是否相等，判断谁大谁小的意义并不是很大
5,字符存取
string s1("hello");
s1.at(2);
//char& operator[](int n); 通过[]方式取字符
s1[2];
//char& at(int n); 通过at方法获取字符
⚠️string字符串中单个字符存取有两种方式，利用 [ ] 或 at
6,插入和删除
string s1("hello");
s1.insert(5," world");
//string& insert(int pos, const string& str); 插入字符串
s1.erase(5,6);
//string& erase(int pos, int n = npos); 删除从Pos开始的n个字符
⚠️插入和删除的起始下标都是从0开始
7,获取子串
string s("hello world");
string s1=s.substr(6,5);
//string substr(int pos = 0, int n = npos) const; 返回由pos开始的n个字符组成的字符串
⚠️灵活的运用求子串功能，可以在实际开发中获取有效的信息

deque容器
deque和vector非常相似，但是在一些地方还是有些不同的；
deque的功能类似于一个双端数组，可以对头端进行插入删除操作；

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

我们知道vector是动态扩展的，那么deque的实现又是怎样的呢？
deque的内部实现和vector有很大不同，deque内部有个中控器，维护每段缓冲区中的内容，缓冲区中存放真实数据
中控器维护（即存放）的是每个缓冲区的地址，使得使用deque时像一片连续的内存空间，但是实际上却是不同地址的一块块连续数据；这样当头端插入数据时可以使用中继器维护的前一个地址对应的内存空间存入该数据，向后端插入数据时可以使用中继器维护的后一个地址对应的内存空间存入该数据；

deque容器的迭代器也是支持随机访问的

deque的好多函数和vector相似，这里重复的就不详细注释了
构造函数

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

成员函数

1，赋值操作
deque<T> d1;
deque<T> d2;
d1=d2;
//deque& operator=(const deque &deq); 重载等号操作符
d1.agssin(d2.begin(),d2.end());
//assign(beg, end); 将[beg, end)区间中的数据拷贝赋值给本身
deque<int> d3;
d3.agssin(10,100);
//assign(n, elem); //将n个elem拷贝赋值给本身。
2，大小操作
deque<T> d1;
d1.empty();
//为真返回true；deque.empty(); 判断容器是否为空
int size=d1.size();
//deque.size(); 返回容器中元素的个数
d1.resize(100);
//deque.resize(num);重新指定容器的长度为num,若容器变长，则以默认值填充新位置。
//如果容器变短，则末尾超出容器长度的元素被删除。
d1.resize(100,10);
//deque.resize(num, elem); 重新指定容器的长度为num,若容器变长，则以elem值填充新位置。
​//如果容器变短，则末尾超出容器长度的元素被删除。
3,插入和删除
deque<T> d1;
d1.push_back(elem);//尾加elem
d1.push_front(elem);//头加elem
d1.pop_back();//尾删最后一个
d1.pop_front();//头删第一个
以下插入删除和vector相同；
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位置的数据，返回下一个数据的位置。
4，数据存取（和vector相同操作）
at(int idx); //返回索引idx所指的数据
operator[]; //返回索引idx所指的数据
front(); //返回容器中第一个数据元素
back(); //返回容器中最后一个数据元素

stack容器
stack容器是一种先进后出的数据结构，就像弹夹一样，先压入的子弹会最后发射出来，而最后压入的子弹却会第一个出来，这就是数据结构：栈；

栈中只有顶端的元素才可以被外界使用，因此栈不允许有遍历行为
（因为一旦遍历就需要有出栈操作，影响了原先的数据）

stack的基本操作很简单，下面介绍几种常用接口：

stack<int> s;//定义了一个整型的栈
s.push(10);
//进栈操作，即压栈，将10压入栈底
s.pop();
//出栈操作
int top=s.top();
//返回栈的顶部数据的操作，返回值为该栈类型
int size=s.size();
//返回栈的大小
s.empty();
//判断栈是否为空栈，若为空则返回true；
总结：
入栈 — push
出栈 — pop
返回栈顶 — top
判断栈是否为空 — empty
返回栈大小 — size

文章部分内容取自《黑马程序员C++教程》；