C++提高笔记（四）---STL容器（stack、queue、list）

已于 2024-03-15 22:36:03 修改
阅读量1.9k 收藏 25
点赞数 42
分类专栏： C++ 文章标签： c++ 开发语言 泛型编程 STL
于 2024-03-15 22:35:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46359434/article/details/136689754
版权

1、stack容器（栈）

1.1 栈stack基本概念

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

栈中只有顶端的元素才可以被外界调用，因此栈不允许有遍历行为（入栈--push、出栈---pop）

1.2 栈stack常用接口

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

构造函数：

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

赋值操作：

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

数据存取：

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

大小操作：

empty();//判断堆栈是否为空
size(); //返回栈的大小
#include <iostream>
using namespace std;
#include<stack>
//栈stack容器
void test01()
{
    //特点：符合先进后出数据结构
    stack<int>s;
    //入栈
    s.push(10);
    s.push(20);
    s.push(30);
    s.push(40);
    //只要栈不为空，查看栈顶，并且执行出栈操作
    while (!s.empty())
    {
        //查看栈顶元素
        cout << "栈顶元素为：" << s.top() << endl;
        //出栈
        s.pop();
    }
    cout << "栈的大小：" << s.size() << endl;
}

int main()
{
    test01();
    system("pause");
    return 0;
}

输出结果：

栈顶元素为：40
栈顶元素为：30
栈顶元素为：20
栈顶元素为：10
栈的大小：0
请按任意键继续. . .

2、queue容器（栈）

2.1queue基本概念

概念：queue是一种先进先出(First In First Out，FIFO)的数据结构，它有两个出口

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

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

队列中进数据称为入队---push

队列中出数据称为出队---pop

2.2queue常用接口

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

构造函数：

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

赋值操作：

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

数据存取：

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

大小操作：

empty();//判断堆栈是否为空
size(); //返回栈的大小
#include <iostream>
using namespace std;
#include<queue>
#include<string>
//queue常用接口
//构造函数:
//queue<T> que;           //queue采用横板类实现，queue对象的默认构造形式
//queue(const queue& que);//拷贝构造函数
//赋值操作:
//queue& operator=(const queue& que);//重载等号操作符
//数据存取:
//push(elem); //往队尾添加元素
//pop();      //从队头移除第一个元素
//back();     //返回最后一个元素
//front();    //返回第一个元素
//大小操作:
//empty();//判断堆栈是否为空
//size(); //返回栈的大小
class Person
{
public:
    Person(string name,int age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }
    string m_Name;
    int m_Age;
};
//queue队列
void test01()
{
    //创建队列
    queue<Person>q;
    //准备数据
    Person p1("唐僧",30);
    Person p2("孙悟空", 1000);
    Person p3("猪八戒", 900);
    Person p4("沙僧", 800);
    //入队
    q.push(p1);
    q.push(p2);
    q.push(p3);
    q.push(p4);
    cout << "队列大小为：" << q.size() << endl;
    //判断只要队列不为空，查看对头，查看队尾，出队
    while (!q.empty())
    {
        //查看对头
        cout << "查看队头---姓名：" << q.front().m_Name << " 年龄：" << q.front().m_Age << endl;
        //查看队尾
        cout << "查看队尾---姓名：" << q.back().m_Name << " 年龄：" << q.back().m_Age << endl;
        //出队
        q.pop();
    }
    cout << "队列大小为：" << q.size() << endl;
}

int main()
{
    test01();
    system("pause");
    return 0;
}

输出结果：

队列大小为：4
查看队头---姓名：唐僧 年龄：30
查看队尾---姓名：沙僧 年龄：800
查看队头---姓名：孙悟空 年龄：1000
查看队尾---姓名：沙僧 年龄：800
查看队头---姓名：猪八戒 年龄：900
查看队尾---姓名：沙僧 年龄：800
查看队头---姓名：沙僧 年龄：800
查看队尾---姓名：沙僧 年龄：800
队列大小为：0
请按任意键继续. . .

3、list容器（链表）

3.1list基本概念

功能：将数据进行链式存储

链表（list）是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的

链表的组成：链表由一系列结点组成

结点的组成：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域

STL中的链表是一个双向循环链表(下图不够准确，第一个节点中prev的null应该指向最后一个节点的data，最后一个节点中next的null应该指向第一个节点的data)

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

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

list的缺点：
        链表灵活，但是空间(指针域)和 时间(遍历)额外耗费较大

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

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

3.2 list构造函数

功能描述：创建list容器

函数原型：

list < T> 1st;          //list采用采用模板类实现,对象的默认构造形式:
list(beg, end);         //构造函数将[beg end)区间中的元素拷贝给本身
list(n, elem);          //构造函数将n个elem拷贝给本身
list(const list& lst);  //拷贝构造函数
#include <iostream>
using namespace std;
#include<list>
//list构造函数
//list < T> 1st;          //list采用采用模板类实现,对象的默认构造形式:
//list(beg, end);         //构造函数将[beg end)区间中的元素拷贝给本身
//list(n, elem);          //构造函数将n个elem拷贝给本身
//list(const list& lst);  //拷贝构造函数
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, 66);
    printList(L4);
}

int main()
{
    test01();
    system("pause");
    return 0;
}

输出结果：

10 20 30 40
10 20 30 40
10 20 30 40
66 66 66 66
请按任意键继续. . .

总结：list构造方式同其他几个STL常用容器相同，熟练掌握即可 

3.3 list赋值和交换

功能描述：给list容器进行赋值，以及交换list容器

函数原型：

assign(beg, end);               //将[beg, end)区间中的数据拷贝赋值给本身
assign(n, elem);                //将n个elem拷贝赋值给本身
list& operator=(const list& lst);//重载等号操作符
swap(lst);                      //将lst与本身的元素互换
#include <iostream>
using namespace std;
#include<list>
//list赋值和交换
//assign(beg, end);               //将[beg, end)区间中的数据拷贝赋值给本身
//assign(n, elem);                //将n个elem拷贝赋值给本身
//list& operator=(const list& lst);//重载等号操作符
//swap(lst);                      //将lst与本身的元素互换
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);
    //operator=赋值
    list<int>L2;
    L2 = L1;
    printList(L2);

    list<int>L3;
    L3.assign(L2.begin(), L2.end());
    printList(L3);

    list<int>L4;
    L4.assign(6, 100);
    printList(L4);
}
//交换
void test02()
{
    list<int>L1;
    L1.push_back(10);
    L1.push_back(20);
    L1.push_back(30);
    L1.push_back(40);
    list<int>L2;
    L2.assign(6, 100);
    cout << "交换前：" << endl;
    printList(L1);
    printList(L2);
    cout << "交换后：" << endl;
    L1.swap(L2);
    printList(L1);
    printList(L2);
}
int main()
{
    test01();
    test02();
    system("pause");
    return 0;
}

输出结果：

10 20 30 40
10 20 30 40
10 20 30 40
100 100 100 100 100 100
交换前：
10 20 30 40
100 100 100 100 100 100
交换后：
100 100 100 100 100 100
10 20 30 40
请按任意键继续. . .

3.4 list大小操作

功能描述：对list容器的大小进行操作

函数原型：

size();           //返回容器中元素的个数
empty();          //判断容器是否为空
resize(num);      //重新指定容器的长度为num，若容器变长，则以默认值填充新位置
                  //如果容器变短，则末尾超出容器长度的元素被删除
resize(num, elem);//重新指定容器的长度为num，若容器变长，则以elem值填充新位置
                  //如果容器变短，则末尾超出容器长度的元素被删除
#include <iostream>
using namespace std;
#include<list>
//list大小操作
//size();           //返回容器中元素的个数
//empty();          //判断容器是否为空
//resize(num);      //重新指定容器的长度为num，若容器变长，则以默认值填充新位置
//                  //如果容器变短，则末尾超出容器长度的元素被删除
//resize(num, elem);//重新指定容器的长度为num，若容器变长，则以elem值填充新位置
//                  //如果容器变短，则末尾超出容器长度的元素被删除
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);
    //判断容器是否为空
    if (L1.empty())
    {
        cout << "L1为空" << endl;
    }
    else
    {
        cout << "L1不为空" << endl;
        cout << "L1的元素个数为：" << L1.size() << endl;
    }
    //重新指定大小
    L1.resize(6, 999);
    printList(L1);

    L1.resize(2);
    printList(L1);
}

int main()
{
    test01();
    system("pause");
    return 0;
}

输出结果：

10 20 30 40
L1不为空
L1的元素个数为：4
10 20 30 40 999 999
10 20
请按任意键继续. . .

3.5 list插入和删除

功能描述：对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值匹配的元素
#include <iostream>
using namespace std;
#include<list>
//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值匹配的元素
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>L;//默认构造
    //尾插
    L.push_back(10);
    L.push_back(20);
    L.push_back(30);
    //头插
    L.push_front(100);
    L.push_front(200);
    L.push_front(300);
    //遍历容器300 200 100 10 20 30
    printList(L);
    //尾删
    L.pop_back();
    printList(L);//300 200 100 10 20
    //头删
    L.pop_front();
    printList(L);//200 100 10 20
    //insert插入
    list<int>::iterator it = L.begin();
    L.insert(++it, 999);//给特定位置插入相应数据
    printList(L);//200 999 10 20
    //删除
    it = L.begin();
    L.erase(it);//可以对it进行操作 删除特定位置数据
    printList(L);//999 10 20
    //移除
    L.push_back(10000);
    L.push_back(10000);
    L.push_back(10000);
    L.push_back(10000);
    L.push_back(10000);
    printList(L);
    L.remove(10000);//把10000全部删除
    printList(L);
    //清空
    L.clear();
    printList(L);
}

int main()
{
    test01();
    system("pause");
    return 0;
}

输出结果：

300 200 100 10 20 30
300 200 100 10 20
200 100 10 20
200 999 100 10 20
999 100 10 20
999 100 10 20 10000 10000 10000 10000 10000
999 100 10 20

请按任意键继续. . .

3.6 list数据存取

功能描述：对list容器中数据进行存取

函数原型：

front(); //返回第一个元素
back();  //返回最后一个元素
#include <iostream>
using namespace std;
#include<list>
//list容器数据存取
//front(); //返回第一个元素
//back();  //返回最后一个元素
void test01()
{
    //创建list容器
    list<int>L1;//默认构造
    //尾插
    L1.push_back(10);
    L1.push_back(20);
    L1.push_back(30);
    L1.push_back(40);
    //L1[0]    不可以用[]访问list容器中的元素
    //L1.at(0) 不可以用at方式访问list容器中的元素
    //原因是list本质是链表，不是用连续线性空间存储数据，迭代器也是不支持随机访问的
    cout << "第一个元素为：" << L1.front() << endl;
    cout << "最后一个元素为：" << L1.back() << endl;
    //验证迭代器是不支持随机访问的
    list<int>::iterator it = L1.begin();
    it++;//支持双向
    it--;
    //it = it + 1;//不支持随机访问
}

int main()
{
    test01();
    system("pause");
    return 0;
}

输出结果：

第一个元素为：10
最后一个元素为：40
请按任意键继续. . .

3.7 list反转和排序

功能描述：将容器中的元素反转，以及将容器中的数据进行排序

函数原型：

reverse(); //反转链表
sort();    //链表排序
#include <iostream>
using namespace std;
#include<list>
#include<algorithm>
//list反转和排序
//reverse(); //反转链表
//sort();    //链表排序

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(20);
    L1.push_back(10);
    L1.push_back(50);
    L1.push_back(40);
    L1.push_back(30);
    cout << "反转前：" << endl;
    printList(L1);
    cout << "反转后：" << endl;
    //反转
    L1.reverse();
    printList(L1);
}

bool myCompare(int v1, int v2)
{
    //降序 就让第一个数 > 第二个数
    return v1 > v2;
}

void test02()
{
    //创建list容器
    list<int>L1;//默认构造
    //尾插
    L1.push_back(20);
    L1.push_back(10);
    L1.push_back(50);
    L1.push_back(40);
    L1.push_back(30);
    cout << "排序前：" << endl;
    printList(L1);
    //所有不支持随机访问迭代器的容器，不可以用标准算法
    //不支持随机访问迭代器的容器，内部会提供对应的一些算法
    //sort(L1.begin(), L1.end());
    cout << "排序后：" << endl;
    L1.sort();//默认排序规则 从小到大 升序
    printList(L1);
    //降序
    L1.sort(myCompare);
    printList(L1);
}

int main()
{
    test01();
    test02();
    system("pause");
    return 0;
}

输出结果：

反转前：
20 10 50 40 30
反转后：
30 40 50 10 20
排序前：
20 10 50 40 30
排序后：
10 20 30 40 50
50 40 30 20 10
请按任意键继续. . .

3.8排序案例

功能描述：将Person自定义数据类型进行排序，Person中属性有姓名，年龄，身高

排序规则：按照年龄进行升序，如果年龄相同按照身高进行降序

#include <iostream>
using namespace std;
#include<string>
#include<list>
#include<algorithm>
//list容器 排序案例 对于自定义数据类型 做排序
//按照年龄进行升序，如果年龄相同按照身高进行降序
class Person
{
public:
    Person(string name, int age, int height)
    {
        this->m_Name = name;
        this->m_Age = age;
        this->m_Height = height;
    }
    string m_Name;//姓名
    int m_Age;//年龄
    int m_Height;//身高
};
//指定排序规则
bool myCompare(Person& p1, Person& p2)
{
    //按照年龄进行升序
    if (p1.m_Age != p2.m_Age)
    {
        return p1.m_Age < p2.m_Age;
    }
    else
    {
        return p1.m_Height > p2.m_Height;
    }
}

void test01()
{
    //创建list容器
    list<Person>L;//默认构造
    //准备数据
    Person p1("刘备", 35, 175);
    Person p2("曹操", 45, 180);
    Person p3("孙权", 40, 170);
    Person p4("赵云", 25, 190);
    Person p5("张飞", 35, 160);
    Person p6("关羽", 35, 200);
    //插入数据 尾插
    L.push_back(p1);
    L.push_back(p2);
    L.push_back(p3);
    L.push_back(p4);
    L.push_back(p5);
    L.push_back(p6);

    for (list<Person>::iterator it = L.begin(); it != L.end(); it++)
    {
        cout << "姓名：" << (*it).m_Name << " 年龄：" << it->m_Age << " 身高：" << it->m_Height << endl;
    }
    //排序
    cout << "------------------------------" << endl;
    cout << "排序后：" << endl;
    L.sort(myCompare);
    for (list<Person>::iterator it = L.begin(); it != L.end(); it++)
    {
        cout << "姓名：" << (*it).m_Name << " 年龄：" << it->m_Age << " 身高：" << it->m_Height << endl;
    }
}

int main()
{
    test01();
    system("pause");
    return 0;
}

输出结果：

姓名：刘备 年龄：35 身高：175
姓名：曹操 年龄：45 身高：180
姓名：孙权 年龄：40 身高：170
姓名：赵云 年龄：25 身高：190
姓名：张飞 年龄：35 身高：160
姓名：关羽 年龄：35 身高：200
------------------------------
排序后：
姓名：赵云 年龄：25 身高：190
姓名：关羽 年龄：35 身高：200
姓名：刘备 年龄：35 身高：175
姓名：张飞 年龄：35 身高：160
姓名：孙权 年龄：40 身高：170
姓名：曹操 年龄：45 身高：180
请按任意键继续. . .

总结：

对于自定义数据类型，必须要指定排序顺序，否则编译器不知道如何进行排序

高级排序只是在排序规则上再进行一次逻辑规则制定，并不复杂

正直和知府
关注
  • 42
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++ STL容器stack和queue详解
09-01
主要介绍了C++ STL容器stack和queue详解的相关资料,需要的朋友可以参考下
【C++】STL 容器 - stack 堆栈容器 ① ( stack 堆栈容器特点 | stack 堆栈容器与 deque 双端数组容器对比 | 简单示例 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
12-23 1077
一、 stack 堆栈容器简介 1、stack 堆栈容器引入 2、stack 堆栈容器特点 3、stack 堆栈容器与 deque 双端数组容器对比 二、 代码示例 - stack 堆栈容器简单示例 1、代码示例 2、执行结果
深入理解C++ STL库中的stack容器
Yoyo的博客
08-12 157
stack容器是一种模板类，定义在头文件中，支持后进先出的原则，即最后插入的元素最先被访问。提供了一种高效的数据结构，适用于需要快速插入和删除元素的场景。只能通过栈顶进行元素的访问和操作，不能访问或修改其他位置的元素。内部使用一个基础容器来存储元素，默认情况下使用deque容器实现。在C++中使用stack容器非常简单，首先需要包含头文件，然后可以使用std::stack// 在栈中插入元素// 访问栈顶元素。
【C++】STL——stack的介绍和使用、stack的push和pop函数介绍和使用、stack的其他成员函数
Crocodile1006的博客
07-30 5589
STL、stack的介绍、stack的使用、stack构造函数、stack成员函数、empty()（检测stack是否为空）size()（返回stack中元素的个数）top()（返回栈顶元素的引用）push()（将元素val压入stack中）pop()（将stack中尾部的元素弹出）
STL详解（二） 栈容器Stack
流年的博客
02-11 3761
一、Stack简介 stack 是容器适配器的一种。要使用 stack，必须包含头文件 <stack>。 stack就是“栈”。栈是一种后进先出的元素序列，访问和删除都只能对栈顶的元素（即最后一个被加入栈的元素）进行，并且元素也只能被添加到栈顶。栈内的元素不能访问。如果一定要访问栈内的元素，只能将其上方的元素全部从栈中删除，使之变成栈顶元素才可以。 容器适配器中的数据是以 LIF...
STL常用容器—stack与queue容器（栈与队列）
weixin_46216674的博客
01-24 891
本文主要介绍C++ STL中的stack和queue两大容器的基本概念与常用方法的调用
STL-常用容器-stack容器（栈）
m0_63736943的博客
08-23 180
/stack采用模板类实现， stack对象的默认构造形式。(First In Last Out,FILO)的数据结构，它只有一个出口。栈中只有顶端的元素才可以被外界使用，因此栈不允许有遍历行为。功能描述：栈容器常用的对外接口。栈中进入数据称为 ---栈中弹出数据称为 ---//从栈顶移除第一个元素。//判断堆栈是否为空。
STL之容器stack
Serven的博客
04-22 1402
STL的stack容器
STL--stack容器
hjl011006的博客
07-10 278
堆栈又名栈（stack），它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素 。
c++ stl栈容器stack的pop(),push()等用法介绍及头文件
热门推荐
l494926429的博客
07-29 7万+
c++ stl栈stack介绍 C++ Stack（堆栈） 是一个容器类的改编，为程序员提供了堆栈的全部功能，——也就是说实现了一个先进后出（FILO）的数据结构。 c++ stl栈stack的头文件为:  #include   c++ stl栈stack的成员函数介绍 操作 比较和分配堆栈 empty() 堆栈为空则返回真 pop() 移除栈顶元素 push() 在栈顶增加元
STL-queue--.rar_stl queue
09-24
STL、线段树代码库 关于队列和栈的有关STL的操作vc++实现
C++ - SGI 版本 STL源码
10-25
C++ SGI版本的STL(标准模板库) 源码 在网上找了很久没有找到直接打包的STL源码, 就打包了一下发出来了 SGI版本的，比较容易阅读 可读性还可以有需要的可以拿走
STL.rar_C++ STL_FSET-885_STL_stl源码_visual c
09-24
STL源码，所有STL源码程序都在眼下，希望你能学会
STL学习笔记-- stack
weixin_34033624的博客
04-10 1879
stack堆栈容器 堆栈是一个线性表，插入和删除只在表的一端进行。这一端称为栈顶(Stack Top)，另一端则为栈底(Stack Bottom)。堆栈的元素插入称为入栈，元素的删除称为出栈。由于元素的入栈和出栈总在栈顶进行，因此，堆栈是一个后进先出(Last In First Out)表，即 LIFO 表。 C++ STL 的堆栈泛化是直接通过现有的序列容器来实现的，默认使用双端...
STL容器【stack】
wuyou的博客
05-04 153
stack
c++实现二叉搜索树（上）
最新发布
henjdx的博客
06-12 996
二叉搜索树1.树节点增加key属性，用来比较谁大谁小，key不可以重复2.对于任意一个节点，它的key比左子树的key都大，同时也比右子树的key都小善解人意的小吉猜很多小可爱们看到这些概念都很难一下子就理解了，接下来小吉画一张图，方便大家理解（比起上面👆的概念，小吉认为下面的图比较重要）注：标的数值都是键值最后，小吉来考考你们🧐，看看你们是否是真的了解了二叉搜索树，上图👆键值6的右子树的取值范围（>6&&
【C++】——Stack与Queue（含优先队列（详细解读）
m0_74092462的博客
06-09 1002
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
C++——计算不同的非空子串个数
我发布的博客，快来抄答案吧
06-09 143
BCSP-X 11题 C++代码详解
C++ -- STL文件解析
08-27
STL是指标准模板库（Standard Template Library），它是C++语言的一部分，提供了一系列的模板类和函数，用于支持通用的数据结构和算法。STL的目标是提供高效、可重用和可扩展的组件，以便开发人员能够更轻松地编写高质量的代码。STL包含了许多常见的数据结构，如vector、list、set、map等，以及各种算法，比如排序、查找、遍历等。通过使用STL，开发人员可以更加高效地处理各种数据结构和算法的问题，提高代码的开发效率和质量。 在STL中，我们可以使用各种容器来存储和管理数据。例如，我们可以使用std::map来创建一个键值对的映射，其中每个键都有一个与之相关联的值。下面是一个示例代码，展示了如何创建和使用一个std::map对象： std::map<std::string, int> disMap() { std::map<std::string, int> tempMap{ {"C语言教程",10},{"STL教程",20} }; return tempMap; } std::map<std::string, int> newMap(disMap()); 在这个示例中，disMap()函数创建了一个临时的std::map对象，并初始化了其中的一些键值对。然后，使用移动构造函数将这个临时对象移动到了一个新的std::map对象newMap中。最终，我们可以通过newMap对象来访问和操作这些键值对。 综上所述，STL是C++中的标准模板库，提供了一系列的模板类和函数，用于支持通用的数据结构和算法。STL的使用可以提高代码的开发效率和质量，并且通过各种容器和算法，可以方便地处理各种数据结构和算法的问题。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [C++ STL详解超全总结(快速入门STL)](https://blog.csdn.net/qq_50285142/article/details/114026148)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] - *2* *3* [【C++实验】阅读STL源码并分析](https://blog.csdn.net/qq_35760825/article/details/125311509)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值