【C++ ：STL常用容器合集】

布逆呲没来

已于 2022-11-20 21:29:59 修改

阅读量164

点赞数

分类专栏： c++笔记文章标签： c++

于 2022-11-20 21:27:11 首次发布

本文链接：https://blog.csdn.net/qq_54549527/article/details/127937432

版权

c++笔记专栏收录该内容

18 篇文章 0 订阅

订阅专栏

STL常用容器

3.1 [string容器](https://blog.csdn.net/qq_54549527/article/details/127676792)
3.2 [vector容器](https://blog.csdn.net/qq_54549527/article/details/127684653)
3.3 [deque容器](https://blog.csdn.net/qq_54549527/article/details/127710149)
3.4 [评委打分:一个案例学会vector容器与deque容器的灵活运用！](https://blog.csdn.net/qq_54549527/article/details/127754429)
3.5 stack容器
- 3.5.1stack基本概念
- 3.5.2 stack常用接口
3.6 queue容器
- 3.6.1 queue基本概念
- 3.6.2 queue常用接口
3.7 list容器
3.8 set/multiset容器
3.9 map/multimap容器

3.1 string容器

3.2 vector容器

3.3 deque容器

3.4 评委打分:一个案例学会vector容器与deque容器的灵活运用！

3.5 stack容器

3.5.1stack基本概念

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

栈中只有顶端的元素才可以被外界使用，因此栈不允许有遍历行为
栈中进入数据称为 —— 入栈 push
栈中弹出数据称为 —— 出栈 pop

3.5.2 stack常用接口

功能描述：栈容器常用的对外接口

构造函数：

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

赋值操作：

stack& operator = (const stack &stk); //重载等号操作符数据存取：
push(elem); //向栈顶添加元素
pop(); //从栈顶移除第一个元素
top(); // 返回栈顶元素大小操作：
empty(); //判断堆栈是否为空
size; //返回栈的大小

3.6 queue容器

3.6.1 queue基本概念

概念：Queue是一种先进先出（First in First Out，FIFO）的数据结构，它有两个出口

队列容器允许从一端新型元素，从另一端移除元素
队列中只有对头和队尾才可以被外界使用，因此队列不允许有遍历行为
队列中进数据称为 —— 入队 push

3.6.2 queue常用接口

功能描述：栈容器常用的对外接口

构造函数：

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

赋值操作：

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

数据存取：

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

大小操作：

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

3.7 list容器

3.7.1 list基本概念

功能：将数据进行链式存储
链表(list)是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的
链表的组成：链表由一系列结点组成
结点的组成：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域

STL中的链表是一个双向循环链表

上图为双向不循环。
由于链表的存储方式并不是连续的内存空间，因此链表list中的迭代器只支持前移和后移，属于双向迭代器，不支持随机访问

list的优点：

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

list的缺点：

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

list有一个重要的性质，插入操作和删除操作都不会造成原有list迭代器的失效，这在vector中是不成立的（因为vector是重新找一段内存，然后销毁之前的）

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

3.7.2 list构造函数

功能描述：创建list容器
函数原型：

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

代码示例：

#include <iostream>
#include <list>
using namespace std;
void printList(const list<int>&l){
    for(list<int>::const_iterator it = l.begin(); it != l.end(); it++){
        cout << *it << " ";
    }
    cout << endl;
}
void test01(){

    //创建list容器
    list<int>L1;   //默认构造
    L1.push_back(10);
    L1.push_back(20);
    L1.push_back(30);
    L1.push_back(40);
    //遍历
    printList(L1);
    //区间方式构造
    list<int>L2(L1.begin(), L1.end());
    printList(L2);
    //拷贝构造
    list<int>L3(L2);
    printList(L3);
    //n个elem
    list<int>L4(4, 1000);
    printList(L4);
}
int main(){
    test01();
    return 0;
}

3.7.3 list赋值和交换

函数原型：

assign(beg, end); //将[beg，end）区间中的数据拷贝赋值给本身
assign(n, elem); //将n个elem拷贝赋值给本身
list& operator=(const list &lst); //重载等号操作符
swap(lst); //将lst与本身的元素互换

3.7.4 list大小操作

函数原型：

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

3.7.4 list插入和删除

函数原型：

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值匹配的元素，不使用迭代器

3.7.6 list数据存取

函数原型：

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

3.7.7 list反转和排序

函数原型：

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

3.8 set/multiset容器

3.8.1 set基本概念

所有元素都会在插入时自动被排序

本质：set/multiset属于关联式容器，底层结构是用二叉树实现。

set和multiset区别：

set不允许容器中有重复的元素，若有重复则只会取一个
multiset允许容器中有重复的元素

3.8.2 set构造和赋值

构造：

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

赋值：

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

3.8.3 set大小和交换

功能描述：统计set容器大小以及交换set容器（因为set容器的特性，故其不提供重新指定set容器容量大小的接口）
函数原型：

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

3.8.4 set插入和删除

函数原型：

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

3.8.5 set查找和统计

功能描述：对set容器进行查找数据以及统计数据
函数原型：

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

3.8.6 set和multiset区别

区别：

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

3.8.7 pair对组创建

功能描述：成对出现的数据，利用对组可以返回两个数据
两种创建方式：

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

代码示例：

void test01(){
    //第一种方式
    pair<string, int>p("Tom", 20);
    cout << "name: "<< p.first << "    age: " << p.second << endl;
    //第二种方式
    pair<string, int>p2 = make_pair("Jerry", 30);
    cout << "name: "<< p2.first << "    age: " << p2.second << endl;
}

3.8.8 set容器排序

set容器默认排序规则为从小到大，掌握如何改变排序规则。
主要技术点：利用仿函数，可以改变排序规则

示例一 set存放内置数据类型

#include <iostream>
#include <set>
using namespace std;
void printSet(set<int>&st){
    for(set<int>::iterator it = st.begin(); it != st.end(); it++)
        cout << *it << " ";
    cout << endl;
}
class MyCompare{
public:
    bool operator()(int v1, int v2){
        return v1 > v2;
    }
};

//set容器排序
void test01(){
    set<int>s1;
    s1.insert(10);
    s1.insert(40);
    s1.insert(30);
    s1.insert(20);
    s1.insert(50);
    printSet(s1);

    //指定排序规则为从大到小
    set<int, MyCompare>s2;
    s2.insert(10);
    s2.insert(40);
    s2.insert(30);
    s2.insert(20);
    s2.insert(50);

    for(set<int, MyCompare>::iterator it = s2.begin(); it != s2.end(); it++)
        cout << *it << " ";
    cout << endl;
}
int main(){
    test01();
    return 0;
}

示例一 set存放内置数据类型自定义数据类型一般都会指定排序规则

#include <iostream>
#include <string>
#include <set>
using namespace std;
//set容器排序，存放自定义数据类型
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对象
    Person p1("gre", 25);
    Person p2("rqw", 26);
    Person p3("cbt", 23);
    Person p4("defr", 12);
    Person p5("vwet", 29);

    s.insert(p1);
    s.insert(p2);
    s.insert(p3);
    s.insert(p4);
    s.insert(p5);

    for(set<Person,comparePerson>::iterator it = s.begin(); it != s.end(); it++){
        cout << "name: " << it->m_Name << "  age: " << it->m_Age << endl;
    }
}
int main(){
    test01();
    return 0;
}

Alt

3.9 map/multimap容器

高性能、高效率的map容器

3.9.1 map基本概念

简介：

map中所有元素都是pair
pair中第一个元素为key（键值），起到索引作用，第二个元素为value（实值）
所有元素都会根据元素的键值自动排序

本质：

map/multimap属于关联式容器，底层结构是用二叉树实现

优点：

可以根据key值快速找到value值

map和multimap区别：

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

3.9.2 map构造和赋值

函数原型：
构造：

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

赋值：

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

#include <iostream>
#include <map>
using namespace std;
void printMap(map<int, int>&m){
    for(map<int, int>::iterator it = m.begin(); it != m.end(); it++){
        cout << "key = " << (*it).first << "  value = " << (*it).second << endl;
    }
    cout << endl;
}
void test01(){
    //创建map容器
    map<int, int>m;
    m.insert(pair<int, int>(1,10)); //匿名对组放入map中
    m.insert(pair<int, int>(3,20));
    m.insert(pair<int, int>(2,30));
    m.insert(pair<int, int>(4,40));
    printMap(m);

    //拷贝构造
    map<int, int>m2(m);
    printMap(m2);

    //赋值
    map<int, int>m3;
    m3 = m2;
    printMap(m3);

}
int main(){
    test01();
    return 0;
}

3.9.3 map大小和交换

函数原型：

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

3.8.4 map插入和删除

函数原型：

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

map容器插入方式共有四种：

void test02(){
    map<int, int>m;
    //第一种
    m.insert(pair<int, int>(1, 10));
    //第二种
    m.insert(make_pair(2,20));
    //第三种
    m.insert(map<int, int>::value_type(3, 30));
    //第四种
    m[4] = 40;
}

为避免插入出错，不建议用[]进行插入，但可以利用[]用key访问到value

3.9.5 map查找和统计

功能描述：对map容器进行查找数据以及统计数据
函数原型：

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

3.9.8 map容器排序

map容器默认排序规则为按照key值从小到大排序，掌握如何改变排序规则。
利用仿函数，可以改变排序规则
若为自定义数据类型，map必须要指定排序规则，同set容器

#include <iostream>
#include <map>
using namespace std;
void printMap(map<int, int>&m){
    for(map<int, int>::iterator it = m.begin(); it != m.end(); it++){
        cout << "key = " << (*it).first << "  value = " << (*it).second << endl;
    }
    cout << endl;
}
class myCompare{
public:
    bool operator()(int v1, int v2){
        return v1 > v2;
    }
};
void test01(){
    map<int, int, myCompare>m;
    m.insert(pair<int, int>(1,10));
    m.insert(pair<int, int>(3,20));
    m.insert(pair<int, int>(2,30));
    m.insert(pair<int, int>(4,40));
    printMap(m);
}
int main(){
    test01();
    return 0;
}

布逆呲没来

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【C++ ：STL常用容器合集】

由于链表的存储方式并不是连续的内存空间，因此链表list中的迭代器只支持前移和后移，属于双向迭代器，不支持随机访问。功能描述：统计set容器大小以及交换set容器（因为set容器的特性，故其不提供重新指定set容器容量大小的接口）map容器默认排序规则为按照key值从小到大排序，掌握如何改变排序规则。栈中只有顶端的元素才可以被外界使用，因此栈不允许有遍历行为。若为自定义数据类型，map必须要指定排序规则，同set容器。功能描述：成对出现的数据，利用对组可以返回两个数据。功能描述：栈容器常用的对外接口。
复制链接

扫一扫