C++的STL简介

已于 2024-07-21 13:00:44 修改
阅读量1.4k 收藏 27
点赞数 38
分类专栏： C++ 算法 文章标签： c++ 开发语言
于 2024-07-19 17:35:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bingbingaidaima/article/details/140546372
版权
算法 同时被 2 个专栏收录
14 篇文章 1 订阅
订阅专栏
C++
3 篇文章 0 订阅
订阅专栏

0.STL简介

C++的STL（Standard Template Library，标准模板库）是C++标准库的一部分，它提供了一套通用的类和函数模板，用于处理数据结构和算法。STL的主要组件包括：

  • 容器
  • 分配器
  • 算法
  • 迭代器
  • 适配器
  • 仿函数
    在这里插入图片描述

容器

容器是用于存储和管理数据元素的类模板。STL中的容器可以分为序列容器和关联容器
在这里插入图片描述

容器适配器

容器适配器是对其他容器进行封装，提供特定的接口，适配特定的使用场景。
在这里插入图片描述

1.vector

vector访问之前一定要预先定义大小！！！！！
vector（矢量）是一种变长数组，即自动改变数组长度的数组
vector可以用来以邻接表的方式存储图

1.1如何使用vector

1.1.1vector的定义

vector<类型名>变量名；
类型名：int ,double, char, struct, STL容器（vector，set，queue）
例：

vector<int> name;
vector<vector<int> >; // > >之间要加空格

vector数组就是一个一维数组，如果定义成vector数组的数组，就是二维数组
（低维是高维的地址）
二维数组中，一维形式就是地址。

# include<vector>
# include<iostream>
using namespace std;

int main()
{
    int arr[3][2];
    cout<<arr[0]<<endl; //输出arr第一行的地址
    cout<<arr[1]<<endl;
    cout<<arr[2]<<endl;

    return 0;
}

1.1.2vector容器内元素的访问

  • 通过下标访问
# include<iostream>
# include<vector>
using namespace std;

int main()
{
    vector<int> vi;
    vi.push_back(1);
    cout<<vi[0]<<endl;

    return 0;
}
  • 通过迭代器访问
    迭代器可以理解为指针
# include<iostream>
# include<vector>
using namespace std;

int main()
{
    vector<int> v;

    for (int i = 0; i < 5; i++)
    {
        v.push_back(i);
    }

    //v.begin()返回v的首元素地址
    vector<int>::iterator it = v.begin();

    for (int i = 0; i < v.size(); i++)
    {
        cout<<it[i]<<" ";
    }

    return 0;

}

其中it[i]可以写成*（it +i）
类似于字符串遍历的for循环写法

    for (vector<int>::iterator it = v.begin(); it!=v.end(); it++)
    {
        cout<<*it<<" ";
    }

1.2vetcor常用函数

在这里插入图片描述

1.3vector常见用途

（1） 存储数据
Vector本身可以作为数组的使用，而且在一些元素个数不确定的场合可以节省空间
（2） 用邻接表存储图
用vector实现邻接表，更为简单

2.string

string是一个字符串类型，和char型字符串类似

  • 头文件
#include<string>
  • 初始化
    string str1; //生成空字符串
    string str2(“12345”,0,3)//结果为“123”，从0位置开始，长度为3
    string str3(“12345678”)//生成12345678的复制品
    string str4(“123456”，5)结果为12345，长度为5

2.1如何使用string

  • 访问单个字符
#include<iostream>
#include<string>
using namespace std;

int main(void)
{
    string s = "ni hao";
    for (int i = 0; i < s.size(); i++)
    {
        cout << s[i] << " ";
    }

    return 0;
}
  • string数组使用
# include<iostream>
# include<string>
using namespace std;
int main(void)
{
    string s[10];
    for (int i = 0; i < 10; i++)
    {
        s[i] = "loading...";
        cout << s[i] << i << "\n";
    }
}

2.2方法函数

2.2.1 获取字符串长度

在这里插入图片描述

2.2.2 插入

在这里插入图片描述

2.2.3 删除

在这里插入图片描述

2.2.4 字符替换

在这里插入图片描述

2.2.5 大小写转换

在这里插入图片描述

2.2.6 分割

在这里插入图片描述

2.2.7 查找

在这里插入图片描述

2.2.8 排序

在这里插入图片描述

2.3C语言与C++的string区别

在这里插入图片描述

3.set

set是一个内部自动有序且不含重复元素的容器
set可以在需要去除重复元素的情况下节省时间，减少思维量
默认升序输出

3.1如何使用set

使用set需加头文件

#include <set>
using namespace std;

set的定义

set<类型名>变量名；
类型名可以是int, double, char, struct, 也可以是STL容器：vector，set，queue
例：

set<struct node> name;
set<set<int> > name; //> >之间有空格

set数组的定义和vector相同：
set<类型名> array[size];

set容器内元素的访问

  • set只能通过迭代器访问
set<int> ::iterator it;
set<char>::iterator it;

得到了迭代器it，并可以通过*it来访问set里的元素
注意：除了vector和string之外的STL容器都不支持(it+i)的访问方式，因此只能按照如下方式枚举*

# include<iostream>
# include<set>
using namespace std;

int main(void)
{
    set<int> st;
    st.insert(5);
    st.insert(2);
    st.insert(6);
    for (set<int>::iterator it = st.begin(); it != st.end(); it++)
    {
        cout<<*it<<" ";
    }
    return 0;
}
输出：2,5,6

3.2set的常用函数

在这里插入图片描述

3.2.1 insert()

#include <iostream>
#include <set>
using namespace std;

int main(void)
{
    set<char> st;
    st.insert('A');
    st.insert('B');
    st.insert('C');

    for (set<char>::iterator it = st.begin(); it != st.end(); it++)
    {
        cout<<*it<<endl;
    }

    return 0;
}

3.2.2 find()

find(value)返回的是set中value所对应的迭代器，即value的指针（地址）

#include <iostream>
#include <set>
using namespace std;

int main(void)
{
    set<int> st;
    for (int i = 1; i <= 3; i++)
    {
        st.insert(i);
    }

    set<int>::iterator it = st.find(2);//在set中查找2，返回迭代器
    cout<< *it<<endl;

    cout<<*(st.find(2))<<endl;

    return 0;
}

3.2.3 erase()

erase（）有两种用法：

  • 删除单个元素
  • 删除一个区间内的所有元素
  1. 删除单个元素
    删除单个元素的方法有两种
    （1） st.erase(it),其中it为所需要删除元素的迭代器（地址）。可以集合find函数来使用
#include <iostream>
#include <set>
using namespace std;

int main(void)
{
    set<int> st;
    st.insert(100);
    st.insert(200);
    st.insert(300);
    //删除单个元素
    st.erase(st.find(100));
    st.erase(st.find(200));

    for (set<int>::iterator it = st.begin(); it != st.end(); it++)
    {
        cout<<*it<<" ";
    }

    return 0;
}

（2） st.erase(value)，value为需要删除元素的值
2.删除一个区间内的所有元素
st.erase(iteratorBegin, iteratorEnd)可以删除一个区间内的所有元素
其中iteratorBegin为所需要删除区间的起始迭代器
iteratorEnd为需要删除区间的结束迭代器的下一个地址
也[iteratorBegin, iteratorEnd]

#include <iostream>
#include <set>
using namespace std;

int main(void)
{
    set<int> st;
    st.insert(100);
    st.insert(200);
    st.insert(300);
    st.insert(400);

    set<int>::iterator it = st.begin();
    st.erase(it, st.find(300));

    for (it = st.begin(); it !=st.end(); it++)
    {
        cout<<*it<<" ";
    }

    return 0;
}

3.3其他set

3.3.1multiset

multiset:元素可以重复，且元素有序

  • 元素可以重复：允许多个相同的元素。
  • 元素有序：内部使用红黑树实现，元素按键值升序排列。
    当你需要一个有序的集合，并且允许重复元素时，使用multiset是一个好选择。
    例：
#include <iostream>
#include <set>

int main() {
    std::multiset<int> ms = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3};

    for (int num : ms) {
        std::cout << num << " ";
    }

    return 0;
}
输出：1 1 2 3 3 4 5 5 6 9

3.3.2unrodered_set

元素无序且只能出现一次

  • 元素无序：内部使用哈希表实现，元素无特定顺序。
  • 元素唯一：不允许重复元素。
    当你需要快速查找元素且不关心顺序，并且不需要重复元素时，unordered_set是一个理想选择。
    例：
#include <iostream>
#include <unordered_set>

int main() {
    std::unordered_set<int> us = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3};

    for (int num : us) {
        std::cout << num << " ";
    }

    return 0;
}
输出：输出顺序不定，可能为6 5 4 3 2 9 1

3.3.3 unordered_multiset

  • 元素无序：内部使用哈希表实现，元素无特定顺序。
  • 元素可以重复：允许多个相同的元素。
    例：
#include <iostream>
#include <unordered_set>

int main() {
    std::unordered_multiset<int> ums = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3};

    for (int num : ums) {
        std::cout << num << " ";
    }

    return 0;
}
输出：输出顺序不定，可能为5 6 5 4 3 3 2 9 1 1

4.map

映射类似于函数的对应关系，每一个x对应一个y，而map是每个键对应一个值，类似与Python的字典

  • 头文件
#include<map>
  • 声明函数
map<string, string> mp;
map<string,int> mp;
map<int, node>//node是结构体

map会按照键的顺序从小到大排序，键的类型必须是可以比较大小

  • 元素有序：基于红黑树实现，元素按键值升序排列。
  • 键唯一：不允许重复的键。

4.1如何使用map

访问map容器内的元素

  • 正向遍历
# include<iostream>
using namespace std;
int main(void)
{
    map<int, int> mp;
    mp[1] = 2;
    mp[2] = 3;
    mp[3] = 4;
    auto it = mp.begin();
    while(it != mp.end())
    {
        cout << it->first << " " << it->second << "\n";
        it++;
    }

    return 0;
}
  • 反向遍历
# include<map>
# include<iostream>
using namespace std;
int main(void)
{
    map<int, int> mp;
    mp[1] = 2;
    mp[2] = 3;
    mp[3] = 4;
    auto it = mp.rbegin();
    while(it != mp.rend())
    {
        cout << it->first << " " << it->second << "\n";
        it++;
    }

    return 0;
}
  • 访问元素
#include<map>
using namespace std;
int main(void)
{
    map<string, string> mp;
    //方式一
    mp["学习"] = "看书";
    mp["玩耍"] = "打游戏";
    //方式二 插入元素构造键值对
    mp.insert(make_pair("vegetables","蔬菜"));
    //方式三
    mp.insert(pair<string, string>("fruit","水果"));
    //方式四
    mp.insert({"hahahahah","wawawaw"});
    //下标访问
    cout<<mp["学习"]<<"\n";
    //迭代器访问
    map<string, string>::iterator it;
    for (it = mp.begin(); it != mp.end(); it++)
    {
        cout<<it->first<<" "<<it->second<<"\n";
    }
    //智能指针访问
    for (auto i : mp)
    {
        cout<<i.first<<" "<<i.second<<endl;
    }
    //对指定的单个元素访问
    map<string, string>::iterator it1 = mp.find("学习");
    cout<<it1->first<<" "<<it1->second<<"\n";
}

4.2map常用函数

在这里插入图片描述

  • 注意点
    查找元素是否存在时，可以使用
  1. mp.find()
  2. mp.count()
  3. mp[key]
    但是第三种情况，如果不存在对应的key时，会自动创建一个键值对（产生额外的键值对，为了不增加额外的空间负担，最好使用前两种方法）

二分查找lower_bound(), upper_bound()

# include<iostream>
# include<map>
using namespace std;

int main(void)
{
    map<int, int> m{{1,2},{2,2},{1,2},{8,2},{6,2}};
    map<int, int>::iterator it1 = m.lower_bound(2);
    cout << it1->first << "\n"; //2
    map<int, int>::iterator it2 = m.upper_bound(2);
    cout << it2->first << "\n"; //6
    return 0;

}

添加元素

# include<iostream>
# include<map>
using namespace std;
int main(void)
{
    map<string, string> mp;
    //方式一
    mp["学习"] = "看书";
    mp["玩耍"] = "打游戏";
    //方式二 插入元素构造键值对
    mp.insert(make_pair("vegetables","蔬菜"));
    //方式三
    mp.insert(pair<string, string>("fruit","水果"));
    //方式四
    mp.insert({"hahahahah","wawawaw"});

    map<string, string>::iterator it = mp.begin();
    while(it != mp.end())
    {
        cout<<it->first<<" "<<it->second<<"\n";
        it++;
    }
    return 0;
}

4.3其他map

4.3.1multimap

  • 元素有序：基于红黑树实现，元素按键值升序排列。
  • 键可以重复：允许多个相同的键。
#include <iostream>
#include <map>

int main() {
    std::multimap<int, std::string> mm;
    mm.insert({1, "one"});
    mm.insert({3, "three"});
    mm.insert({2, "two"});
    mm.insert({1, "uno"});

    for (const auto& pair : mm) {
        std::cout << pair.first << ": " << pair.second << "\n";
    }

    return 0;
}
输出：输出：1: one 1: uno 2: two 3: three

4.3.2unordered_map

  • 元素无序：基于哈希表实现，元素无特定顺序。
  • 键唯一：不允许重复的键。
  • 快速访问：平均情况下，插入和查找操作的时间复杂度为O(1)。
    例：
#include <iostream>
#include <unordered_map>

int main() {
    std::unordered_map<int, std::string> um;
    um[1] = "one";
    um[3] = "three";
    um[2] = "two";

    for (const auto& pair : um) {
        std::cout << pair.first << ": " << pair.second << "\n";
    }

    return 0;
}
输出：输出顺序不定，可能为2: two 1: one 3: three

4.3.3unordered_multimap

  • 元素无序：基于哈希表实现，元素无特定顺序。
  • 键可以重复：允许多个相同的键。
  • 快速访问：平均情况下，插入和查找操作的时间复杂度为O(1)。
    例：
#include <iostream>
#include <unordered_map>

int main() {
    std::unordered_multimap<int, std::string> umm;
    umm.insert({1, "one"});
    umm.insert({3, "three"});
    umm.insert({2, "two"});
    umm.insert({1, "uno"});

    for (const auto& pair : umm) {
        std::cout << pair.first << ": " << pair.second << "\n";
    }

    return 0;
}
输出：输出顺序不定，可能为1: one 1: uno 2: two 3: three

5.pair

5.1介绍

pair只含有两个元素，可以看做是只有两个元素的结构体
头文件

#include<utility>

应用：

  • 代替二元结构体
  • 作为map的键值进行插入
#include<utility>
#include<iostream>
#include<map>
using namespace std;

int main(void)
{
    map<string, int> mp;
    mp.insert(pair<string, int>("xiaoming",11));

    pair<string, int> p;
    p = pair<string, int>("wang", 18);
    p = make_pair("li", 16);
    p = {"sun", 24};

    return 0;
}

5.2访问

# include<iostream>
# include<utility>
using namespace std;
int main(void)
{
    pair<int, int>p[20];
    for (int i = 0; i < 20; i++)
    {
        cout << p[i].first << " " << p[i].second;
    }

    return 0;
}

6.queue

6.1介绍

队列是一种先进先出的数据结构
queue 仅允许访问队首（第一个元素）和队尾（最后一个元素），你无法通过索引直接访问中间元素

  • 头文件
#include<queue>
  • 声明
queue<int>  q;

6.2queue常用函数

代码含义
q.front()返回队首元素
q.back()返回队尾元素
q.push(ele)尾部添加一个元素ele
q.pop()删除第一个元素
q.size()返回队列中元素的个数，返回值类型unsigned int
q.empty()判断是否为空，队列为空，返回true

6.3队列模拟

使用q[]数组模拟队列
hh表示队首元素的下标，初始值为0
tt表示队尾元素的下标，初始值为-1，表示队列刚开始为空

#include<iostream>
using namespace std;

const int N = 1e5 + 5;
int q[N];

int main(void)
{
    int hh = 0;
    int tt = -1;
    //入队
    q[++tt] = 1;
    q[++tt] = 2;
    while (hh <= tt)
    {
        int t = q[hh++];
        printf("%d\n", t);
    }
    return 0;
}

7deque

7.1介绍

首尾都可插入和删除的队列为双端队列

  • 头文件
#include<deque>
  • 声明
deque<int> dq;

7.2函数

在这里插入图片描述

8.priority_queue

8.1介绍

优先队列是在正常队列的基础上加了优先级，保证每次的队首元素都是优先级最大的
可以实现每次从优先队列中取出的元素都是队列中优先级最大的
它的底层是通过堆来实现的

  • 头文件
#include<queue>
  • 声明函数
priority_queue<int> q;

8.2函数

在这里插入图片描述

8.3设置优先级

基本数据类型的优先级

priority_queue<int> pq; // 默认大顶堆，即每次取出的元素是队列中的最大值

priority_queue<int, vector<int>, greater<int> > q; //小根堆。每次取出的元素是队列中的最小值

第一个参数：优先队列中存储的数据类型
第二个参数：是用来承载底层数据结构堆的容器，若优先队列中存放的是double类型，就要填vector ，总之存的是什么数据类型，就相应的填写对应的数据类型，同时要改动第三个参数的对应类型
第三个参数
less 数字大的优先级大，堆顶为最大的数字
greater数字小的优先级大，堆顶为最小的数字

高级数据类型（结构体）优先级

  • 自定义全局比较规则
#include<queue>
#include<iostream>
using namespace std;

struct Point
{
    int x;
};

struct cmp //自定义堆的排序规则
{
    bool operator()(const Point& a, const Point& b)
    {
        return a.x < b.x;
    }
};
priority_queue<Point, vector<Point>,cmp> q; //x大的在堆顶
  • 直接在结构体里写
    在这里插入图片描述

存储特殊类型的优先级

存储pair类型
排序规则：首先对pair的first进行降序排序，再对second降序排序
对first先排序，大的排在前面，如果first元素相同，在对second元素排序，保持大的在前面

# include<queue>
# include<iostream>
using namespace std;

int main(void)
{
    priority_queue<pair<int, int> > q;
    q.push({7,8});
    q.push({7,9});
    q.push(make_pair(8,7));
    while (!q.empty())
    {
        cout << q.top().first << " "<<q.top().second << "\n";
        q.pop();
    }
    return 0;
}

9.stack

9.1如何使用stack

定义

STL中实现的一个先进后出的容器

  • 添加头文件
#include<stack>
  • 声明
stack<int> s;
stack<string> s;
stack<node> s; //node是结构体类型

stack容器内元素的访问

栈提供push和pop等等接口，所有元素必须符合先进后出规则，所以栈不提供走访功能，也不提供迭代器（iterator）。不像set或map提供迭代器来遍历所有元素。
STL中栈往往不被归类为容器，而是容器适配器（container adapter），栈以底层容器完成所有的工作，对外提供统一的接口，底层容器是可插拔的（可以控制哪种容器来实现栈）。
在这里插入图片描述

  • 栈遍历

栈只能对栈顶元素进行操作，如果要进行遍历，只能将栈中元素一个个取出来存在数组中

  • 数组模拟栈遍历
    通过一个数组对栈进行模拟，一个存放下标的变量top模拟指向栈顶的指针
    比STL的stack 更快，遍历元素方便
    在这里插入图片描述

9.2stack常用函数

在这里插入图片描述

10.bitset

10.1如何使用bitset

定义

类似数组，每个元素只能是0或1，每个元素只占用1bit空间

  • 头文件
#include<bitset>
  • 初始化定义
    在这里插入代码片在这里插入图片描述
# include<iostream>
# include<bitset>
using namespace std;
int main(void)
{
    bitset<4> bitset1;
    bitset<9> bitset2(12);
    string s = "100101";
    bitset<10> bitset3(s); //长度为10，前面用0补充

    char s2[] = "10101";
    bitset<13> bitset4(s2);

    cout<<bitset1<<endl; //0000
    cout<<bitset2<<endl; //000001100
    cout<<bitset3<<endl;//0000100101

    return 0;
}

特性

可进行位操作
在这里插入图片描述

访问

#include<iostream>
#include<bitset>
using namespace std;
int main(void)
{
    bitset<4> f("1011");
    for(int i = 0; i < 4; i++)
    {
        cout << f[i];
    }
    return 0;
}//输出1101

bitset优化

一般使用bitset来优化时间复杂度
bitset还有开动态空间的技巧，常用在01背包优化等算法中

10.2bitset的常用函数

在这里插入图片描述

11.array

array是c++新增的容器，效率与普通数据相差无几，比vector效率要高，自身添加了一些成员函数，和其他容器相比，array容器的大小是固定的，无法动态地扩展和收缩，只允许访问或替换存储的元素
注意：array的使用要在std的命名空间里

11.1如何使用array

声明与初始化

在这里插入图片描述

存取元素

#include<iostream>
#include<array>

using namespace std;
int main(void)
{
    //修改元素
    array<int, 4> a = {1, 2, 3, 4};
    a[0] = 4;
    //访问元素
    for (int i = 0; i < 4; i++)
    {
        cout << a[i] << "\n";
    }
    //auto访问
    for (auto i : a)
    {
        cout << i <<" ";
    }
    //迭代器访问
    auto it1 = a.begin();
    for (; it1 != a.end(); it1++)
    {
        cout << *it1 <<" ";
    }
    //at函数访问
    int res = a.at(1) + a.at(2);
    cout<<res<<"\n"; //res=5;
    //get方法访问
    get<1>(a) = 100; //将数组下标为1的地方改成100
    cout<<a[1];
}

11.2array常用函数

在这里插入图片描述

12.tuple

tuple是pair的泛化，可以封装不同类型任意数量的对象
可以将tuple理解为pair的扩展，tuple可以声明二元组，也可以声明三元组
tuple可以等价为结构体使用

12.1定义

  • 头文件
#include<tuple>
  • 声明初始化
# include<tuple>
# include<iostream>
using namespace std;
int main(void)
{
    tuple<int, int, string> t1;
    //赋值
    t1 = make_tuple(1,1,"hahha");
    //创建的同时初始化
    tuple<int, int, int, int>t2(1,2,3,4);
    //使用pair对象构造tuple对象，但tuple对象必须是两个元素
    auto p = make_pair("wang", 1);
    tuple<string, int>t3{p}; //将pair对象赋给tuple对象

    return 0;
}

12.2元素操作

# include<tuple>
# include<iostream>
using namespace std;
int main(void)
{
    tuple<int, int, string> t1;
    //赋值
    t1 = make_tuple(1,1,"hahha");
    //创建的同时初始化
    tuple<int, int, int, int>t2(1,2,3,4);
    //使用pair对象构造tuple对象，但tuple对象必须是两个元素
    auto p = make_pair("wang", 1);
    tuple<string, int>t3{p}; //将pair对象赋给tuple对象
    int first = get<0>(t2); //获取t2的第一个元素
    get<0>(t2) = 100;
    cout<<get<0>(t2)<<"\n";

    return 0;
}

12.3函数操作

在这里插入图片描述

13 读入详解

cin

读入字符串，遇空格， 回车结束
在这里插入图片描述

getline

读入一行字符串（包括空格），遇到回车结束
在这里插入图片描述
注意getline(cin， s)会获取前一个输入的换行符，需要在前面添加读取换行符的语句，如getchar()或cin.get()
在这里插入图片描述
cin与getline（）混用
cin输入完后，回车，cin遇到回车结束输入，但回车还在输入流中，cin不会清除，导致getline（）读取回车，结束。需要在cin后面加cin.ignore();主动删除输入流中的换行符

cin与cout解锁

在这里插入图片描述
在这里插入图片描述
注意：cin与cout解锁使用时，不能与scanf，getchar，printf，cin，getline（）混用，一定要注意，会出错

14智能指针

14.1auto

auto是自动推断元素的类型，一般用来遍历
例如vector num
for (auto &i ：nums)
&i 表示 i 是 nums中每个元素的引用，而不是副本。使用引用可以避免不必要的拷贝，提高效率。
遍历二维数组

vector<vector<int>> res;
    for (const auto& row : res)
    {
        for (int num : row)
        {
            cout << num << " ";
        }
        cout << endl;
    }

使用const auto&

  • auto可以自动判断数据类型， &是对数据进行引用，而不是拷贝，节省内存提高效率。
  • const保证在遍历时不对res的数据做修改，安全。

auto it和auto& it的区别

  • auto it 会创建元素的副本，因此对 it 的修改不会影响原容器中的元素。
  • auto &it 是对元素的引用，因此对 it 的修改会直接影响原容器中的元素

。
智能指针详解

docisaku
关注
  • 38
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++：什么是STL？
Sunrise的博客
06-09 1万+
什么是STL？1. STL概论1.1. STL基本概念1.2. STL六大组件简介1.3. STL优点2. STL三大组件2.1. 容器2.2. 算法2.3. 迭代器2.3. 案例 1. STL概论   长久以来，软件界一直希望建立一种可重复利用的东西，以及一种得以制造出”可重复运用的东西”的方法,让程序员的心血不止于随时间的迁移，人事异动而烟消云散，从函数(functions)，类别(classes),函数库(function libraries),类别库(class libraries)、各种组件，从模
c++stl简介
12-11
C++ STL，全称Standard Template Library，是C++标准库的一部分，它提供了一组高效的工具，包括容器、迭代器、算法、函数对象、适配器和内存分配器，旨在简化和加速程序设计。这些组件相互协作，使得程序员能够以一...
c++ STL模板
11-08
向量vector是一种随机访问的数组类型，提供了对数组元素的快速、随机访问以及在序列尾部快速、随机的插入和删除操作。它是大小可变的向量，在需要是可以改变其大小。 形式：
C++重点---STL简介
顾得泉的博客
02-28 2113
本文主要对C++中的STL进行了简介。
C++的STL详细内容（零基础轻松学）
最新发布
Mr_Wang30986的博客
04-17 990
vector是将元素置于一个动态数组中加以管理的容器vector可以随机存取元素（支持索引值直接存取，用[]操作符或at()的方法）vector尾部添加或移除元素非常快速，但是中部或头部插入或移除元素比较费时deque是“double-ended queue"的缩写，和vector一样都是STL的容器deque是双端数组而vector是单端的deque在接口上和vector非常相似，在许多操作的地方可以直接替换。
C++ STL使用
u012477435的博客
09-23 1984
文章目录C++ STL使用一、什么是STL二、STL内容介绍2.1 STL中六大组件2.2 容器2.3 迭代器2.4 算法2.4.1 算法分类2.5 仿函数2.5.1 仿函数(functor)在编程语言中的应用2.5.2 仿函数在STL中的定义2.6 容器适配器2.6.1 stack2.6.2 queue & priority_queue三、常用容器用法介绍3.1 vector3.1.1 基本函数实现3.1.2 基本用法3.1.3 实例3.2 deque3.2.1 声明deque容器3.2.2 de
C++中的STL
nthzduang_的博客
08-16 311
C++的STL中的string、vector、list以及map性质和相关函数用法
C++——STL
lggbxf的博客
05-29 530
C++——STL六大组件容器算法迭代器仿函数适配器空间配置器STL的三大组件容器算法迭代器 长久以来，软件界一直希望建立一种可重复利用的东西，以及一种得以制造出”可重复运用的东西”的方法,让程序员的心血不止于随时间的迁移，人事异动而烟消云散，从函数(functions)，类别(classes),函数库(function libraries),类别库(class libraries)、各种组件，从模...
C++STL
BIGBIGPPT的博客
04-10 545
各种STL动态数组（vector）声明使用操作队列（queue）声明循环队列操作优先队列（堆）大根堆（队头最大）小根堆（队头最小）①相反数插入实现②重载运算符实现使用未完待续QwQ 动态数组（vector） 声明 代码 #include<vector> vector <int> a; //一维动态数组 vector <int> b[777];//第一维长777...
C++ STL简介
01-15
STL简介，简要介绍了C++语言的一个重要组成部分-标准模板库(STL)，对于深入学习C++有启发作用
C++ STL 简介
08-13
#### 一、STL简介 STL（Standard Template Library，标准模板库）是惠普实验室开发的一系列软件组件，最初由Alexander Stepanov、Meng Lee 和 David R. Musser 在惠普实验室工作期间开发。虽然STL现在主要与C++语言...
C++ STL教程pdf
05-10
C++ STL，全称为Standard Template Library（标准模板库），是C++编程语言中不可或缺的一部分，它为程序员提供了高效且灵活的编程工具。STL的核心概念包括泛型编程、容器、迭代器、算法和函数对象，这些组件共同构成...
【C++】 STL详解
热门推荐
m0_56051805的博客
10-01 2万+
【C++】 STL详解
c++之STL详解
ltzoro的博客
08-04 5677
万字长文带你深度了解c++STL
C++的STL
Mr Harsh的博客
08-11 2378
STL的代码从广义上讲分为三类：algorithm（算法）、container（容器）和iterator（迭代器），几乎所有的代码都采用了模板类和模板函数的方式，这相比于传统的由函数和类组成的库来说。
C++ 中的STL
weixin_39829031的博客
02-13 170
STL中的基本概念 STL（Standard Template Library），标准模板库。 容器：容纳各种数据类型的通用数据结构，是类模板 迭代器：依次存取容器中的元素，类似指针 算法：操作容器中的元素的函数模板 容器的分类 顺序容器：vector , deque , list 关联容器：set , mutiset , map , mutimap 容器适配器：stack , queue ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值