C+++——STL(序列容器)

已于 2024-07-01 09:37:49 修改
阅读量188 收藏
点赞数
分类专栏： C++ 文章标签： c++ 开发语言
于 2021-05-11 15:33:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dedication_/article/details/116561349
版权

序列容器：

类型备注
array增加了成员函数begin() end() at()与全局函数get()等；不可增删，固定大小；
vector默认尾删增；内存连续；
deque双向队列；相对vector增加了头删增；内存可不连续；
list双向链表
forward_list前向链表/单向链表

代码：（运行需要自行注释部分代码）

（array）

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

int main() {
    array<int, 5> nums = {};//申明类型为int大小为5的array
    for (int i = 0; i < nums.size(); i++)//对array赋值 at()代替[]更加安全
        nums.at(i) = i;
    for (auto iter = nums.begin(); iter != nums.end(); iter++)//使用指针遍历array
        cout << *iter << " ";
    cout << get<2>(nums);//使用全局函数get<>()获取指定位置元素
    return 0;
}

（vector）

#include<iostream>
#include<vector>
#include<algorithm>//用于remove()
using namespace std;

int main() {
    //声明
    vector<int> nums;//默认大小0
    vector<int> nums(10);//大小为10，默认值为0
    vector<int> nums(10, 1.0);//大小为10，默认值为1.0
    vector<int> nums = { 1,2,3,4,5,5,5,6 };//大小为5
    vector<int> nums2(nums);//直接复制nums的值与大小
    vector<int> nums2(nums.begin(), nums.begin() + 3);//复制nums前3元素
    
    //遍历
    for (int iter : nums)
        cout << iter << " ";
    for (auto iter = nums.begin(); iter != nums.end(); iter++)
        cout << *iter << " ";
    for (int iter = 0; iter < nums.size(); iter++)
        cout << "nums[" << iter << "]=" <<nums[iter]<<" ";

    //尾部增加与删减
    nums.push_back(6);//先创建元素再移动拷贝
    nums.emplace_back(6);//直接在尾部创建元素
    nums.pop_back();

    //特定位置增加
    nums.insert(nums.begin()+2, 1);//在nums[2]插入1
    nums.insert(nums.begin()+2, 5, 3);//在nums[2]插入5个3
    nums.insert(nums.begin() + 2, nums2.begin(), nums2.end());//在nums[2]插入nums2
    nums.insert(nums.begin() + 2, { 4,5,9,8,100 });//在nums[2]插入{ 4,5,9,8,100 }
    nums.emplace(nums.begin() + 2, 300);//在nums[2]插入300 emplace只能插入单个元素 但效率比insert高

    //特定位置的删除
    nums.erase(nums.begin()+3);//删除nums[3]
    nums.erase(nums.begin(), nums.begin() + 2);//删除前两个元素

    //特定值的删除（remove()在algorithm中 不改变vector的size和capacity)
    auto iter1=remove(nums.begin(), nums.end(), 5);//移除所有为5的元素
    for (auto iter=nums.begin();iter!=iter1;iter++)//输出移除后的vector
        cout << *iter << " ";

    nums.clear();//容器清空
    nums.swap(nums2);//向量元素交换

    return 0;
}

（deque）

#include<iostream>
#include<deque>
#include<algorithm>
using namespace std;

int main() {
    //声明
    //deque<int> nums;//默认大小0
    //deque<int> nums(10);//大小为10，默认值为0
    //deque<int> nums(10, 1.0);//大小为10，默认值为1.0
    deque<int> nums = { 1,2,3,4,5,5,5,6 };//大小为5
    //deque<int> nums2(nums);//直接复制nums的值与大小
    deque<int> nums2(nums.begin(), nums.begin() + 3);//复制nums前3元素
    
    //遍历
    cout << endl;
    for (int iter : nums)
        cout << iter << " ";
    for (auto iter = nums.begin(); iter != nums.end(); iter++)
        cout << *iter << " ";
    for (int iter = 0; iter < nums.size(); iter++)
        cout << "nums[" << iter << "]=" <<nums[iter]<<" ";

    //头部增加与删减
    nums.push_front(6);//先创建元素再移动拷贝
    nums.emplace_front(6);//直接在尾部创建元素
    nums.pop_front();

    //尾部增加与删减
    nums.push_back(6);//先创建元素再移动拷贝
    nums.emplace_back(6);//直接在尾部创建元素
    nums.pop_back();

    //特定位置增加
    nums.insert(nums.begin()+2, 1);//在nums[2]插入1
    nums.insert(nums.begin()+2, 5, 3);//在nums[2]插入5个3
    nums.insert(nums.begin() + 2, nums2.begin(), nums2.end());//在nums[2]插入nums2
    nums.insert(nums.begin() + 2, { 4,5,9,8,100 });//在nums[2]插入{ 4,5,9,8,100 }
    nums.emplace(nums.begin() + 2, 300);//在nums[2]插入300 emplace只能插入单个元素 但效率比insert高

    //特定位置的删除
    nums.erase(nums.begin()+3);//删除nums[3]
    nums.erase(nums.begin(), nums.begin() + 2);//删除前两个元素

    //特定值的删除（remove()在algorithm中 不改变deque的size)
    auto iter1=remove(nums.begin(), nums.end(), 6);//移除所有为6的元素
    for (auto iter=nums.begin();iter!=iter1;iter++)//输出移除后的deque
        cout << *iter << " ";

    nums.clear();//容器清空
    nums.swap(nums2);//双向队列元素交换

    return 0;
}

（list）

#include<iostream>
#include<list>
#include<array>
#include<algorithm>
using namespace std;
bool demo(int first, int second) {
    return (first == second);
}
int main() {
    //声明
    //list<int> nums;//默认大小0
    //list<int> nums(10);//大小为10，默认值为0
    //list<int> nums(10, 1.0);//大小为10，默认值为1.0
    //list<int> nums2(nums);//复制nums
    int arr1[] = { 5,5,5,6,6,6 };
    list<int> nums(arr1, arr1 + 5);//复制arr前5元素
    array<int, 7> arr2= { 1,2,5,6,7,8 };
    list<int> nums2(arr2.begin(), arr2.begin() + 3);//复制arr前3元素
    
    //遍历
    cout << endl;
    for (int iter : nums)//顺序输出
        cout << iter << " ";
    //cout << endl;
    //for (auto iter = nums.begin(); iter != nums.end(); iter++)//顺序输出
    //    cout << *iter << " ";
    //cout << endl;
    //for (auto iter = nums.rbegin(); iter != nums.rend(); iter++)//逆向输出
    //    cout << *iter << " ";

    头部增加与删减
    nums.push_front(6);//先创建元素再移动拷贝
    nums.emplace_front(6);//直接在尾部创建元素
    nums.pop_front();

    尾部增加与删减
    nums.push_back(6);//先创建元素再移动拷贝
    nums.emplace_back(6);//直接在尾部创建元素
    nums.pop_back();

    特定位置增加
    nums.insert(nums.begin()+2, 1);//在nums[2]插入1
    nums.insert(nums.begin()+2, 5, 3);//在nums[2]插入5个3
    nums.insert(++nums.begin(), nums2.begin(), nums2.end());//在begin后1位插入nums2
    nums.insert(++nums.begin(), { 4,5,9,8,100 });//在begin后1位插入{ 4,5,9,8,100 }
    nums.emplace(++nums.begin(), 300);//在begin后1位插入300 emplace只能插入单个元素 但效率比insert高
    nums.splice(++nums.begin(), nums2);//插入整个nums2
    nums.splice(++nums.begin(), nums2, ++nums2.begin());//裁剪nums2第二个位置
    nums.splice(++nums.begin(), nums2, ++nums2.begin(), nums2.end());//第二个位置到倒数第一个位置

    特定位置的删除
    nums.erase(++nums.begin());//删除第二个元素
    nums.erase(++nums.begin(), nums.end());//删除第二个元素到最后一个元素

    nums.remove(6);//移除所有为6的元素
    nums.remove_if([](int value) {return value < 2; });//移除小于2的元素
    nums.unique();//移除相邻重复的元素
    nums.unique(demo);//移除相邻重复的元素 demo为逻辑函数

    nums.clear();//容器清空
    nums.swap(nums2);//元素交换
    nums.reverse();//元素反转
    nums.merge(nums2);//有序deque合并 原本有序 合并后也有序

    return 0;
}

（forward_list）

#include<iostream>
#include<forward_list>
#include<array>
#include<algorithm>
#include<iterator>
using namespace std;

int main() {
    //声明
    /*forward_list<int> nums;
    forward_list<int> nums(10);
    forward_list<int> nums(10, 5);
    forward_list<int> nums1(nums);*/
    int arr1[] = { 5,5,5,6,6,6 };
    forward_list<int> nums(arr1, arr1 + 5);
    array<int, 5 > arr2= {99, 84, 5, 6, 123};
    forward_list<int> nums2(arr2.begin(), arr2.end());
    
    //遍历
    cout << endl;
    for (int iter : nums)//顺序输出
        cout << iter << " ";
    //cout << endl;
    //for (auto iter = nums.begin(); iter != nums.end(); iter++)//顺序输出
    //    cout << *iter << " ";
    //cout << endl;
    
    //在头部增删
    nums.push_front(100);
    nums.emplace_front(101);
    nums.pop_front();

    //在特定位置增删
    nums.emplace_after(++nums.begin(), 100);
    nums.insert_after(++nums.begin(), 100);
    nums.erase_after(nums.begin());

  	nums.splice_after(nums.begin(), nums2);//将nums2指定位置 插入nums指定位置
    nums.splice_after(nums.begin(),nums2, ++nums2.begin());
    nums.splice_after(nums.begin(), nums2, ++nums2.begin(), nums2.end());
    nums.remove(100);//移除100
    nums.remove_if([](int value) {return value < 98; });//移除小于98
    nums.unique();//删除相邻重复元素
    
    nums.swap(nums2);//交换
    nums.merge(nums2);//合并
    nums.sort();//排序
    nums.reverse();//逆转
    nums.clear();//清空
    
	distance(nums.begin(), nums.end());//返回列表元素个数 头文件<iterator>
	
    return 0;
}
Your_Julia
关注
专栏目录
(c/c++)——STL
qq_43199575的博客
09-20 411
迭代器是访问容器中元素的通用方法。注意begin()和end()的位置 迭代器可以理解为指针和移动指针的一种方式。正向迭代器如下定义（支持++）： 常用的容器中迭代器种类为双向迭代器（支持++、- -）和随机访问迭代器（支持++、- -、+n，-n、下标运算[n]）。随机访问迭代器最明显的一个特征：下标运算[n]。不难看出，一般是在有固定位置的序列式容器中才能使用，支持随机访问迭代器的有：vector、deque、array、string，此外，数组指针也是一种随机访问迭代器，因为数组指针也可以++，- -
c++ || STL序列容器
LQEmptycity的博客
08-02 538
STL 、vector、list、deque、
C++序列式容器
klaseT的博客
03-30 205
序列容器，即以线性排列来存储某一指定类型（例如 int、double 等）的数据，需要特殊说明的是，该类容器并不会自动对存储的元素按照值的大小进行排序。 序列容器只是一类容器的统称，并不指具体的某个容器，序列容器大致包含以下几类容器： array< T,N >（数组容器）：表示可以存储 N 个 T 类型的元素，是 C++ 本身提供的一种容器。此类容器一旦建立，其长度就是固定不变的，这意...
C++ STL 序列式容器 array/vector/deque/list
kaimMarch的博客
02-26 997
array 容器是在 C++ 普通数组的基础上，添加了一些成员函数和全局函数。在使用上，它比普通数组更安全，且效率并没有因此变差。array 容器的大小是固定的，无法动态的扩展或收缩，这也就意味着，在使用该容器的过程无法借由增加或移除元素而改变其大小，它只允许访问或者替换存储的元素。 array 容器以类模板的形式定义在 <array> 头文件，并位于命名空间 std 中。 #include <array> using namespace std; //构造 array<int
c++STL容器之序列式容器
一个小菜鸡的学习之路
04-16 1081
序列式容器（Sequence containers）在c++中主要有三种：。
C++ STL序列式容器（详解）
qq_25218501的博客
08-18 876
尽管不同容器对应着不同类别的迭代器，但这些迭代器有着较为统一的定义方式，具体分为 4 种，如表 1 所示。迭代器定义方式具体格式正向迭代器容器类名::iterator 迭代器名;常量正向迭代器容器类名::const_iterator 迭代器名;反向迭代器容器类名::reverse_iterator 迭代器名;常量反向迭代器容器类名::const_reverse_iterator 迭代器名;
C++STL——序列式容器(向量vector与双端队列deque)
最新发布
Rudy1124的博客
08-28 190
大概就讲这么多，更多STL容器C++STL——序列式容器2。QAQ。
C++11——序列式容器总结
dadaima_sama的博客
03-25 429
目录 容器： vector ——顺序表。 list ——环状双向链表 deque——双开口数组 容器适配器： stack——先进后出 queue——先进先出 heap——堆（隐式表达） #include<aglorithm> priority_queue——优先队列 标准之外： slist——单链表 vector ——顺序表。 概述：vect...
C++——STL之vector详解
weixin_59055853的博客
12-21 1878
学习了string之后，学习其他模板将会更容易上手，一起来看一下vector吧！vector是表示大小可以变化的数组的序列容器。
C++学习——STl实验
hshagahhva的博客
11-28 956
一：STL简介 STL也叫做标准模板库，定义了一套概念体系，为泛型程序设计提供了逻辑基础。STL中的各个类模板、函数模板的参数都是用这个体系中的概念来规定的。 使用STL的模板时，类型参数既可以是C++标准库中已有的类型，也可以是自定义的类型——只要这些类型是所要求概念的模型 STL的基本组件包括容器，迭代器，函数对象和算法。容器包含各种数据结构，如vector、list、deque、set、map等,用来存放数据；迭代器扮演了容器与算法之间的胶合剂，是一种将operat...
C++ 实现序列化
11-03
C++实现序列化，简单的讲是将C++里的对象（此处是广义上的对象，内置类型或者用户自定义类型）数据变成char*，即单个字节的数据，这样方便传输等，涉及到的知识点有C++中的函数重载，操作符重写，allcotor，左值和右值，继承，模板等
c++ STL 容器——序列
weixin_30536513的博客
05-02 99
STL中11个容器类型分别是deque,list,queue,priority_queue,stack,vector,map,multimap,set,multiset,bieset(在比特级处理数据的容器，不讨论） 一些基本的容器特征 表达式　 返回值 说明 复杂度 XX:iterator 对应迭代器 指针 编译时间 X u 创建一个...
C++笔记 C++标准模板库（STL）之序列容器详解
weixin_40933653的博客
07-31 492
并且更重要的一点是，deque容器中存储元素并不能保证所有元素都存储到连续的内存空间中，严格的讲，其没有capacity的概念，是动态地以分段连续空间组合而成，随时可以增加一段新的空间并链接起来，也就是说它不用像vector那样去预留一部分空间，即reserve功能。，提供了访问容器中对象的方法。例如，STL用sort()来对一个vector中的数据进行排序，用find()来搜索一个list中的对象，函数本身与他们操作的数据的结构和类型无关，因此他们可以在从简单数组到高度复杂容器的任何数据结构上使用；...
C++序列容器
qq_40553788的博客
05-14 100
C++ 中的序列容器是一种可以存储一系列元素的容器，这些元素按照一定的顺序排列。C++ 中的序列容器包括以下几种：vector：动态数组，支持随机访问和尾部插入删除操作。deque：双端队列，支持随机访问和头尾插入删除操作。list：双向链表，支持顺序访问和任意位置插入删除操作。forward_list：单向链表，支持顺序访问和任意位置插入删除操作。array：静态数组，支持随机访问和固定大小。string：字符串，是基于 char 类型的 vector，支持字符串操作。
C++序列式容器(数据线性排列)
weixin_42647166的博客
04-23 474
目录序列式容器介绍array数组容器vector向量容器deque双向队列list双向链表forward_list单向链表 序列式容器介绍   所谓的序列容器就是以线性排列（类似于数组的存储方式）来存储某一指定类型的数据（int、double···），该类容器不会自动对存储的元素按照值得大小进行排序。   序列式容器大致包含下面几类： array< T,N >(数组容器)：表示可存储...
C++STL——序列容器（vector、deque、array、list、forward_list）
小白一直白
04-17 560
目录介绍vectordequearraylistforward_list 介绍 序列容器（Sequence Containers）也叫作顺序容器，序列容器各元素之间有顺序关系，每个元素都有固定位置，除非使用插入或删除操作改变这个元素的位置。 特点 可以在容器一端添加、删除元素 序列容器有连续存储和链式存储两种存储方式 顺序都是由程序设计者决定的 vector vector容器与动态数组相同，在插入或删除元素时能够自动调整自身大小，即vector容器能够自动处理存储数据所需的空间。 特点
c++ 序列
weixin_30511039的博客
08-11 883
题目描述 生活中，大多数事物都是有序的，因为顺序的美是最令人陶醉的。所以现在RCDH看了不顺的东西就头痛。所以他想让世界变成有序，可是他只是一个无名小辈，所以只好对数字序列下手。 据他所知序列的混乱程度是由“逆序对”的个数决定，公式是Q=2^n,其中Q是指混乱程度，n是指这个序列“逆序对”的个数。逆序对是这样定义的：假设序列中第i个数是ai，若存在i<j,使得ai>aj，则&...
数据结构-序列容器(C++)
zxf121703的专栏
04-14 327
vector,array,list,forward_list,deque,stack,queue,priority_queue
STL序列式容器详解：向动态数组学习
"序列式容器是C++ Standard Template Library (STL) 的核心组成部分，专注于提供一种高效、灵活的数据结构管理方式。STL旨在通过抽象和泛型编程，简化程序员在处理各种数据结构和算法时的工作。本篇文章将详细介绍...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值