标签：总结容器 end 迭代 iterator STL 元素学习 const

常用容器

string容器

基本概念

string是C++风格的字符串，本质上是一个类。其内部封装了char*。
成员函数主要有find，copy，delete，replace，insert

构造函数

string();//生成空string
string(const char* s);//以字符串s初始化
string(const string& str);//以string对象初始化另一个string对象
string(int n, char c);//以n个字符c初始化

赋值操作

string& operator=(const char* s);
string& operator=(const string &s);
string& operator=(char c);
string& assign(const char *s)
string& assign(const char *s, int n)
string& assign(const string &s)
string& assign(int n, char c);

字符串拼接

string& operator+=(const char* str);
string& operator+=(const char c);
string& operator+=(const string& str);
string& append(const char* s)
string& append(const char* s,int n);
string& append(const string& str);
string& append(const string &s,int pos,int n);//字符串s中从pos开始的n个字符连接到字符串结尾

查找和替换

int find(const string& str, int pos = 0) const;//从pos开始查找str出现的第一次位置
int find(const char* s,int pos = 0) const//从pos开始查找s出现的第一次位置
int fing(const char* s, int pos, int n) const;//从pos开始查找s的前n个字符出现的第一次位置
int find(const char c,int pos = 0) const//从pos开始查找c出现的第一次位置
int rfind(const string& str, int pos = npos) const;//从pos开始查找str出现的最后一次位置
int rfind(const char* s,int pos = npos) const//从pos开始查找s出现的最后一次位置
int rfind(const char* s, int pos, int n) const;//从pos开始查找s的前n个字符出现的最后一次位置
int find(const char c,int pos = 0) const//从pos开始查找c出现的最后一次位置
sting& replace(int pos, int n, const string& str)//替换从pos开始n个字符为字符串str
sting& replace(int pos, int n, const char* s)//替换从pos开始n个字符为字符串s
find是从左往右，rfind是从右往左，二者都是寻找第一次找到的字符或字符串，故从结果上来看find的结果是从左到右第一次出现的位置，rfind的结果是从左到右最后一次出现的位置。
find和rfind找不到字符时返回-1。
replace在替换时要指定替换的开始位置、字符数量和字符内容。

字符串比较

比较方式：按ASCII码进行比较。
= 返回 0
> 返回 1
< 返回 -1
int compare(const string& s) const;
int compare(const char* s) const;

字符串存取

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

插入和删除

string& insert(int pos, const char* s);
string& insert(int pos, const string& str);
string& insert(int pos, int n, char c);//在pos位置插入n个字符c
string& erase(int pos, int n = npos);//删除从pos开始的n个字符
string& erase(pos);//删除pos处的一个字符
erase(first,last);//删除从first到last之间的字符
插入和删除的下标都是从0开始。

子串

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

vector容器

基本概念

vector数据结构和数组十分相似，也称为单端数组。
数组是静态空间，而vector可以动态扩展。
动态扩展：并不是在原空间之后续接新空间，而是找更大的内存空间，然后将原数据拷贝新空间，释放原空间
vector的迭代器是支持随机访问的迭代器

构造函数

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

赋值操作

vector& operator=(const vector& vec);
assign(beg, end);//将[beg, end)区间中的元素拷贝给本身
assign(n, elem);//将n个elem拷贝给本身

容量和大小

empty();//判断容器是否为空
capacity();//容器的容量
size();//容器的元素的个数
resize(int num);//重新指定容器的长度为num。若容器变长，则以默认值填充新位置；若容器变短，则多出的元素将被删除。
resize(int num, elem);//重新指定容器的长度为num。若容器变长，则以elem填充新位置；若容器变短，则多出的元素将被删除。

插入和删除

push_back(elem);//尾插元素elem
pop_back();//删除最后一个元素
insert(const_iterator pos, elem);//迭代器指向位置pos插入元素elem
insert(const_iterator pos, int count, elem);//迭代器指向位置pos插入count个元素elem
erase(const_iterator pos);//删除迭代器指向的元素
erase(const_iterator start, const_iterator end);//删除迭代器从start到end之间的元素
clear();//删除容器中所有元素

数据存取

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

互换容器

swap(vec);//将vec与本身的元素互换
swap可以使两个容器互换，可以达到收缩内存效果。

预留空间

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

deque容器

基本概念

vector对于头部的插入效率低，数据量越大，效率越低。deque相对而言对头部的插入速度更快。但是vector访问元素的速度更快。这与两者内部的实现有关。
内部工作原理：deque内部有个中控器，维护每段缓冲区的内容，缓冲区中存放真实数据。中控器维护的是每个缓冲区的地址，使得使用deque时像一片连续的内存空间。
deque容器的迭代器也是支持随机访问的。

构造函数

deque<T>depT;
deque(beg,end);//将[beg, end)区间中的元素拷贝给本身
deque(n,elem);//将n个elem拷贝给本身
deque(const deque& dep);//拷贝构造函数

赋值操作

deque& operator=(const deque& dep);
assign(beg, end);//将[beg, end)区间中的元素拷贝给本身
assign(n, elem);//拷贝构造函数

大小操作

deque.empty();//判断容器是否为空
deque.size();//返回容器中元素的个数
deuqe.resize(int num);//重新指定容器的长度为num。若容器变长，则以默认值填充新位置；若容器变短，则多出的元素将被删除。
dque.resize(int num, elem);//重新指定容器的长度为num。若容器变长，则以elem填充新位置；若容器变短，则多出的元素将被删除。
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)区间的数据u，返回下一个数据的位置
erase(pos);//删除pos位置的数据，返回下一个数据的位置
插入和删除提供的位置是迭代器

数据存取

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

排序

sort(iterator beg, iterator end);//对beg和end之间的元素进行排序
sort算法使用时应包含头文件 algorithm。

stack容器

基本概念

stack是一种先进后出的数据结构，它只有一个出口。栈中只有顶端的元素才可以被外界使用，因此栈不允许有遍历行为。栈中进出数据称为入栈，栈中弹出数据称为出栈。

常用接口

构造函数

stack<T> stk;
stack(const stack& stk);//拷贝构造

赋值操作

stack& operator=(const stack& stk);

数据存取

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

大小操作

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

queue容器

基本概念

queue是一种先进先出的数据结构，它有两个出口。队列容器允许从一端新增元素，从另一端移除元素。队列中只允许队头和队尾才可以被外界使用，因此队列不允许有遍历行为。队列中进数据称为入队(push)，出数据称为出队(pop)。

构造函数

queue<T> que;
queue(const queue& que);//拷贝构造

赋值操作

queue& operator=(const queue& que);

数据存取

push(elem);//往队尾添加元素
pop();//删除队头第一个元素
back();//返回最后一个元素
front();//返回第一个元素

大小操作

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

list容器

基本概念

链表是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针连接实现的。链表由一系列结点组成。结点有数据域和下一个结点地点的指针域组成。STL的链表是一个双向循环链表。由于链表的存储方式并不是连续的内存空间，因此链表list中的迭代器只支持前移和后移，属于双向迭代器。
list的优点是采用动态存储分配，不会造成内存浪费和溢出；链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素。
list的缺点是链表灵活，但是空间（指针域）和时间（遍历）额外耗费较大。
list有一个重要的性质，插入和删除操作都不会造成原有list迭代器的失效，这在vector是不成立的。

构造函数

list<T> lst;
list(beg, end);//将[beg, end)区间中的元素拷贝给本身
list(n, elem);//将n个elem拷贝给本身
list(const list& lst);//拷贝构造函数

赋值与交换

assign(beg, end);//将[beg, end)区间中的元素拷贝给本身
asign(n, elem);//将n个elem拷贝给本身
list& operator = (const list& lst);
swap(lst);//将lst于本身的元素互换

大小操作

size();//返回容器中元素的个数
empty();//判断容器是否为空
resize();//重新指定容器的长度为num。若容器变长，则以默认值填充新位置；若容器变短，则多出的元素将被删除。
resize(int num, elem);//重新指定容器的长度为num。若容器变长，则以elem填充新位置；若容器变短，则多出的元素将被删除。

插入和删除

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值匹配的元素

数据存取

front();//返回第一个元素
back();//返回最后一个元素
list容器中不可以通过[]或者at方式访问数据。

反转和排序

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

set/ multiset容器

基本概念

所有元素都会在插入时自动排序。
set/ multiset属于关联式容器，底层结构由二叉树实现。
区别：set不允许容器中有重复的元素；multiset允许容器中有重复元素。

构造和赋值

set<T> st;
set(const set& st);//拷贝构造函数
set& operator=(const set& st);

大小和交换

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

插入和删除

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

查找和统计

find(key);//查找key是否存在，若存在返回该元素的迭代器；若不存在返回set.end()
count(key);//统计key的元素个数（对于set，结果为0或1）

set和multiset的区别

set不可以插入重复数据，而multiset可以。
set插入数据的同时会返回插入结果，表示插入是否成功。返回的内容为对组，first为迭代器，second为bool。
multiset不会检测数据，因此可以插入重复数据。

pair对组创建

pair<type, type> p ( value1, value2 );
pair<type, type> p = make_pair( value, value2 );

容器排序

set/ multiset容器容器默认排序规则为从小到大，可利用仿函数改变排序规则。

#include <set>
#include <string>
class Person {
    public:
    Person(string name, int age) {
        this->m_Name = name;
        this->m_Age = age;
    }
    string m_Name;
    int m_Age;
};
//仿函数
class comparePerson {
    public:
    bool operator()(const Person& p1, const Person &p2) {
        //按照年龄进行排序  降序
        return p1.m_Age > p2.m_Age;
    }
};

void test01()
{
    set<Person, comparePerson> s;

    Person p1("刘备", 23);
    Person p2("关羽", 27);
    Person p3("张飞", 25);
    Person p4("赵云", 21);

    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() {

    test01();

    system("pause");

    return 0;
}

map/ multimap容器

基本概念

map/ multimap容器中所有容器都是pair。
pair中第一个元素为key，起到索引作用，第二个元素为value。
所有元素都会根据元素的key自动排序。
map/ multimap容器数据关联式容器，底层结构由二叉树实现。
可以根据key值快速找到value值。
区别：map不允许容器中有重复key值元素；multimap允许容器中有重复key值元素。

构造和赋值

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

大小和交换

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

插入和删除

map中所有元素都是成对出现，插入数据时候要使用对组
insert(elem);//插入元素elem
clear();//清除所有元素
erase(pos);//删除pos迭代器所指的元素，返回下一个元素的迭代器
erase(beg, end);//删除区间[beg,end)的所有元素，返回下一个元素的迭代器
erakey(key);//删除容器中值为key的元素

查找和统计

find(key);//查找key是否存在，若存在返回该元素的迭代器；若不存在返回map.end()
count(key);//统计key的元素个数（对于map，结果为0或1）

容器排序

map/ multimap容器容器默认排序规则为从小到大，可利用仿函数改变排序规则。

#include <map>

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

void test01() {
    //默认从小到大排序
    //利用仿函数实现从大到小排序
    map<int, int, MyCompare> m;

    m.insert(make_pair(1, 10));
    m.insert(make_pair(2, 20));
    m.insert(make_pair(3, 30));
    m.insert(make_pair(4, 40));
    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;
    }
}
int main() {

    test01();

    system("pause");

    return 0;
}

常用算法

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

常用遍历算法

for_each

for_each(iterator beg, iterator end, _func);// beg 开始迭代器; end 结束迭代器; _func 函数或者函数对象
实现容器的遍历

transform

transform(iterator beg1, iterator end1, iterator beg2, _func);//beg1 源容器开始迭代器; end1 源容器结束迭代器; beg2 目标容器开始迭代器; _func 函数或者函数对象
搬运容器到另一个容器中
搬运的目标容器必须要提前开辟空间，否则无法正常搬运

常用查找算法

find

find(iterator beg, iterator end, value);//beg 开始迭代器; end 结束迭代器; value 查找的元素
按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置

find_if

find_if(iterator beg, iterator end, _Pred);// beg 开始迭代器; end 结束迭代器; _Pred 函数或者谓词（返回bool类型的仿函数）
按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置

adjacent_find

adjacent_find(iterator beg, iterator end);//beg 开始迭代器; end 结束迭代器
查找相邻重复元素,返回相邻元素的第一个位置的迭代器

binary_search

bool binary_search(iterator beg, iterator end, value);// beg 开始迭代器;end 结束迭代器;value 查找的元素
查找指定的元素，查到返回true 否则false
在无序序列中不可用

count

count(iterator beg, iterator end, value);// beg 开始迭代器; end 结束迭代器; value 统计的元素
统计元素出现次数
统计自定义数据类型时，需要配合重载 operator==

count_if

count_if(iterator beg, iterator end, _Pred);// beg 开始迭代器; end 结束迭代器; _Pred 谓词
按条件统计元素出现次数

常用排序算法

sort

sort(iterator beg, iterator end, _Pred);//beg 开始迭代器; end 结束迭代器; _Pred 谓词
按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置

random_shuffle

random_shuffle(iterator beg, iterator end);//beg 开始迭代器; end 结束迭代器
指定范围内的元素随机调整次序
使用时需要添加随机数种子

merge

merge(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);//beg1 容器1开始迭代器; end1 容器1结束迭代器; beg2 容器2开始迭代器; end2 容器2结束迭代器; dest 目标容器开始迭代器
容器元素合并，并存储到另一容器中
两个容器必须是有序的

reverse

reverse(iterator beg, iterator end);//beg 开始迭代器; end 结束迭代器
反转指定范围的元素

常用拷贝和替换算法

copy

copy(iterator beg, iterator end, iterator dest); //beg 开始迭代器; end 结束迭代器; dest 目标起始迭代器
按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置

replace

replace(iterator beg, iterator end, oldvalue, newvalue);//beg 开始迭代器; end 结束迭代器; oldvalue 旧元素; newvalue 新元素
将区间内旧元素替换成新元素

replace_if

replace_if(iterator beg, iterator end, _Pred, newvalue);//beg 开始迭代器; end 结束迭代器; _pred 谓词; newvalue 替换的新元素
按条件替换元素，满足条件的替换成指定元素

swap

swap(container c1, container c2);//c1容器1; c2容器2
互换两个容器的元素，两个容器要同种类型

常用算术生成算法

算术生成算法属于小型算法，使用时包含的头文件为#include

accumulate

accumulate(iterator beg, iterator end, value);//beg 开始迭代器； end 结束迭代器； value 起始值
计算容器元素累计总和

fill

fill(iterator beg, iterator end, value); //beg 开始迭代器; end 结束迭代器; value 填充的值
向容器中填充指定元素

常用集合算法

set_intersection

set_intersection(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);// beg1 容器1开始迭代器; end1 容器1结束迭代器; beg2 容器2开始迭代器; end2 容器2结束迭代器; dest 目标容器开始迭代器
求两个集合的交集
两个集合必须是有序序列
目标容器开辟空间需要从两个容器中取小值
set_intersection返回值既是交集中最后一个元素的位置

set_union

set_union(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);//beg1 容器1开始迭代器; end1 容器1结束迭代器; beg2 容器2开始迭代器; end2 容器2结束迭代器; dest 目标容器开始迭代器
求两个集合的并集
两个集合必须是有序序列
目标容器开辟空间需要两个容器相加
set_union返回值既是并集中最后一个元素的位置

set_difference

set_difference(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);//beg1 容器1开始迭代器; end1 容器1结束迭代器; beg2 容器2开始迭代器; end2 容器2结束迭代器; dest 目标容器开始迭代器
求两个集合的差集
两个集合必须是有序序列
目标容器开辟空间需要从两个容器取较大值
set_difference返回值是差集中最后一个元素的位置

标签：总结,容器,end,迭代,iterator,STL,元素,学习,const
From： https://blog.csdn.net/m0_52229131/article/details/140492299

STL学习总结

常用容器

string容器

基本概念

构造函数

赋值操作

字符串拼接

查找和替换

字符串比较

字符串存取

插入和删除

子串

vector容器

基本概念

构造函数

赋值操作

容量和大小

插入和删除

数据存取

互换容器

预留空间

deque容器

基本概念

构造函数

赋值操作

大小操作

插入和删除

数据存取

排序

stack容器

基本概念

常用接口

queue容器

基本概念

list容器

基本概念

构造函数

赋值与交换

大小操作

插入和删除

数据存取

反转和排序

set/ multiset容器

基本概念

构造和赋值

大小和交换

插入和删除

查找和统计

set和multiset的区别

pair对组创建

容器排序

map/ multimap容器

基本概念

构造和赋值

大小和交换

插入和删除

查找和统计

容器排序

常用算法

常用遍历算法

for_each

transform

常用查找算法

find

find_if

adjacent_find

binary_search

count

count_if

常用排序算法

sort

random_shuffle

merge

reverse

常用拷贝和替换算法

copy

replace

replace_if

swap

常用算术生成算法