1. string

1.1 基本概念

string是C++风格的字符串，本质上是一个类。在头文件 <string> 中。string管理char*所分配的内存，不用担心复制越界和取值越界等，由类内部进行负责。

string和char * 区别：

• char * 是一个指针；
• string是一个类，类内部封装了char * ，管理这个字符串，是一个char * 型的容器。

1.2 构造函数

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

1.3 赋值操作

// string赋值方式较多，一般常用 = 进行赋值
string& operator=(const char* s);          // char*类型字符串 赋值给当前的字符串
string& operator=(const string &s);        // 把字符串s赋给当前的字符串
string& operator=(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赋给当前字符串

1.4 字符串拼接

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个字符连接到字符串结尾

1.5 查找和替换

// 查找
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 rfind(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

1.6 字符串比较

int compare(const string &s) const;    // 与字符串s比较，大于返回1，等于返回0，小于返回-1
int compare(const char *s) const;      // 与字符串s比较

1.7 直接操作串中字符

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

1.8 插入和删除

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个字符 

1.9 获取子串

string substr(int pos = 0, int n = npos) const;   // 返回由pos开始的n个字符组成的字符串

2. vector

2.1 基本概念

vector数据结构和数组非常相似，也称为单端数组。不同之处在于数组是静态空间，而vector可以动态扩展。动态扩展并不是在原空间之后续接新空间，而是找更大的内存空间，然后将原数据拷贝新空间，释放原空间。

2.2 构造函数

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

2.3 赋值操作

vector& operator=(const vector &vec);   // 重载等号操作符

assign(beg, end);       // 将[beg, end)区间中的数据拷贝赋值给本身。
assign(n, elem);        // 将n个elem拷贝赋值给本身。

2.4 容量和大小

empty();                // 判断容器是否为空
capacity();             // 容器的容量
size();                 // 返回容器中元素的个数

resize(int num);        // 重新指定容器的长度为num，若容器变长，则以默认值填充新位置。
                        // 如果容器变短，则末尾超出容器长度的元素被删除。
resize(int num, elem);  // 重新指定容器的长度为num，若容器变长，则以elem值填充新位置。
                        // 如果容器变短，则末尾超出容器长度的元素被删除

reserve(int len);       // 容器预留len个元素长度，预留位置不初始化，元素不可访问。

2.5 插入和删除

push_back(ele);      // 尾部插入元素ele
pop_back();          // 删除最后一个元素

insert(const_iterator pos, ele);            // 迭代器指向位置pos插入元素ele
insert(const_iterator pos, int count,ele);  // 迭代器指向位置pos插入count个元素ele

erase(const_iterator pos)                           // 删除迭代器指向的元素
erase(const_iterator start, const_iterator end);    // 删除迭代器从start到end之间的元素

clear();            // 删除容器中所有元素

2.6 数据存取

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

2.7 容器互换

swap(vec);      // 将vec与本身的元素互换

3. deque

3.1 基本概念

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

deque与vector区别：

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

deque内部工作原理:

deque内部有个中控器，维护每段缓冲区中的内容，缓冲区中存放真实数据

中控器维护的是每个缓冲区的地址，使得使用deque时像一片连续的内存空间

3.2 构造函数

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

3.3 赋值操作

deque& operator=(const deque &deq);    //重载等号操作符

assign(beg, end);                      //将[beg, end)区间中的数据拷贝赋值给本身。
assign(n, elem);                       //将n个elem拷贝赋值给本身

3.4 容量操作

deque.empty();              // 判断容器是否为空
deque.size();               // 返回容器中元素的个数

deque.resize(num);          // 重新指定容器的长度为num,若容器变长，则以默认值填充新位置。
                            // 如果容器变短，则末尾超出容器长度的元素被删除。
deque.resize(num, elem);    // 重新指定容器的长度为num,若容器变长，则以elem值填充新位置。
                            // 如果容器变短，则末尾超出容器长度的元素被删除。

3.5 插入和删除

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.6 数据存取

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

4. queue

4.1 基本概念

queue为队列，是一种先进先出(First In First Out, FIFO)的数据结构，有两个出口。

队列容器允许从一端新增元素，从另一端移除元素。

队列中只有队头和队尾才可以被外界使用，因此队列不允许有遍历行为。

4.2 基本操作

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

// 赋值操作
queue& operator=(const queue &que);     // 重载等号操作符

// 数据存取
push(elem);          // 往队尾添加元素
pop();               // 从队头移除第一个元素
back();              // 返回最后一个元素
front();             // 返回第一个元素

// 大小操作
empty();             // 判断队列是否为空
size();              // 返回队列的大小

5. stack

5.1 基本概念

stack为栈，是一种先进后出(First In Last Out, FILO)的数据结构，只有一个出口。

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

5.2 基本操作

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

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

// 数据存取
push(elem);      // 向栈顶添加元素
pop();           // 从栈顶移除第一个元素
top();           // 返回栈顶元素

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

6. list

6.1 基本概念

list为链表，是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的。链表由一系列结点组成，结点由存储数据元素的数据域和存储下一个结点地址的指针域组成。

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

list的优点：

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

list的缺点：

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

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

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

6.2 构造函数

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

6.3 赋值和交换

list& operator=(const list &lst);   // 重载等号操作符

assign(beg, end);            // 将[beg, end)区间中的数据拷贝赋值给本身
assign(n, elem);             // 将n个elem拷贝赋值给本身

swap(lst);                   // 将lst与本身的元素互换

6.4 大小操作

size();                 // 返回容器中元素的个数
empty();                // 判断容器是否为空

resize(num);            // 重新指定容器的长度为num，若容器变长，则以默认值填充新位置。
                        // 如果容器变短，则末尾超出容器长度的元素被删除。
resize(num, elem);      // 重新指定容器的长度为num，若容器变长，则以elem值填充新位置。
                        // 如果容器变短，则末尾超出容器长度的元素被删除。

6.5 插入和删除

push_back(elem);        // 在容器尾部加入一个元素
pop_back();             // 删除容器中最后一个元素
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值匹配的元素

6.6 数据存取

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

6.7 反转和排序

reverse();   // 反转链表
sort();      // 链表排序

7. set / multiset

7.1 基本概念

set即集合，所有元素都会在插入时自动被排序。set/multiset属于关联式容器，底层结构是用二叉树实现。set容器默认排序规则为从小到大，利用仿函数可以改变排序规则。

7.2 构造和赋值

set<T> st;                // 默认构造函数：
set(const set &st);       // 拷贝构造函数

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

7.4 大小和交换

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

7.5 插入和删除

insert(elem);       // 在容器中插入元素。
clear();            // 清除所有元素

erase(pos);         // 删除pos迭代器所指的元素，返回下一个元素的迭代器。
erase(beg, end);    // 删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。
erase(elem);        // 删除容器中值为elem的元素。

7.6 查找和统计

find(key);       // 查找key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回set.end();
count(key);      // 统计key的元素个数

7.7 set和multiset区别

• set不可以插入重复数据，而multiset可以
• set插入数据的同时会返回插入结果，表示插入是否成功
• multiset不会检测数据，因此可以插入重复数据

7.8 pair对组

// 成对出现的数据，利用对组可以返回两个数据
pair<type, type> p ( value1, value2 );
pair<type, type> p = make_pair( value1, value2 );

8. map / multimap

8.1 基本概念

map/multimap属于关联式容器，底层结构是用二叉树实现。map中所有元素都是pair，pair中第一个元素为key（键值），起到索引作用，第二个元素为value（实值）。所有元素都会根据元素的键值自动排序，可以根据key值快速找到value值。

map容器默认排序规则为按照key值进行从小到大排序，利用仿函数可以改变排序规则。

map和multimap区别：

• map不允许容器中有重复key值元素
• multimap允许容器中有重复key值元素

8.2 构造和赋值

map<T1, T2> mp;                 // map默认构造函数
map(const map &mp);             // 拷贝构造函数

map& operator=(const map &mp);  // 重载等号操作符

8.3 大小和交换

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

8.4 插入和删除

insert(elem);       // 在容器中插入元素。
clear();            // 清除所有元素
erase(pos);         // 删除pos迭代器所指的元素，返回下一个元素的迭代器
erase(beg, end);    // 删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器
erase(key);         // 删除容器中值为key的元素

8.5 查找和统计

find(key);        // 查找key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回set.end();
count(key);       // 统计key的元素个数