C++中的各种容器的使用方法汇总

目录
  • vector
    • 构造函数
    • 迭代器iterator
    • 访问元素
    • 插入与删除元素
  • deque
    • 构造函数
    • 迭代器iterator
    • 访问元素
    • 插入与删除元素
    • insert函数
    • queue
    • Priority Queues(优先队列)
  • stact
  • list
    • 构造函数
    • 迭代器iterator
    • 访问元素
    • 插入与删除元素
    • insert函数
    • 合并链表
  • set
    • 构造函数
    • 迭代器iterator
    • 插入与删除元素
    • unordered_set
  • map
    • 构造函数
    • 迭代器iterator
    • 插入与删除元素
    • find()与count()
    • unordered_map

vector

vector是封装动态数组的顺序容器。元素相继存储,这意味着不仅可通过迭代器,还能用指向元素的常规指针访问元素。这意味着指向 vector 元素的指针能传递给任何期待指向数组元素的指针的函数。

构造函数

//空的vector容器
vector<int>v1;
//size为5,值的初始化为0的vector容器
vector<int>v2(5);
//size为5,值的初始化为1的vector容器
vector<int>v3(5, 1);
//创建vector时就初始化
vector<int>v4 = { 1,3,4,5,7 };
//利用别的vector创建初始化vector
vector<int>v5(v4);
//指定起始与结束内容创建与初始化
vector<int>v6(v4.begin()+3, v4.end());

迭代器iterator

begin() 返回第一个元素的迭代器
end() 返回最末元素的迭代器
rbegin() 返回Vector尾部的逆迭代器
rend() 返回Vector起始的逆迭代器 

访问元素

v.at(i)	//返回vector v指定位置的元素
v[i]	//返回vector v指定位置的元素
v.back() //返回最末一个元素
v.front() //返回第一个元素 

插入与删除元素

void push_back( const TYPE &val ); //在Vector最后添加一个元素
void pop_back(); //移除最后一个元素
iterator erase( iterator loc );	//删除指定loc元素
iterator erase( iterator start, iterator end );	//删除[start,end)元素

v.push_back(3);	//vector最后添加元素3
v.pop_back();	//删除vector最后一个元素
v.erase(v.begin());//删除位置为begin的元素
v.erase(v.begin(),v.end());//删除区间[begin(),end())的元素

insert函数

//在指定位置loc前插入值为val的元素,返回指向这个元素的迭代器,
iterator insert( iterator loc, const TYPE &val );
//在指定位置loc前插入num个值为val的元素
void insert( iterator loc, size_type num, const TYPE &val );
//在指定位置loc前插入区间[start, end)的所有元素
void insert( iterator loc, input_iterator start, input_iterator end );

v.insert(v.begin(),1);//在begin()位置插入元素1
v.insert(v.begin(),5,1);//在begin()位置插入5个值为1的元素
v.insert(v.begin(),v1.begin(),v1.end());//在begin()位置插入区间[v1.begin(),v1.end())的元素

deque

是有下标顺序容器,它允许在其首尾两段快速插入及删除。另外,在 deque 任一端插入或删除不会非法化指向其余元素的指针或引用。

构造函数

//无参,创建一个空双向队列
deque();
//size - 创建一个大小为size的双向队列
deque( size_type size );
//num and val - 放置num个val的拷贝到队列中
deque( size_type num, const TYPE &val );
//from - 从from创建一个内容一样的双向队列
deque( const deque &from );
//start 和 end - 创建一个队列,保存从start到end的元素
deque( input_iterator start, input_iterator end );

deque<int>d1;//空双向队列
deque<int>d2(5);//大小为5,值为0的双向队列
deque<int>d3(5,1);//大小为5,值为1的双向队列
deque<int>d4(d3);//创建一个与d3相同的双向队列
deque<int>d5(d3.begin(),d3.end());
deque<int>d6 = {1,4,6,8};//初始化队列

迭代器iterator

begin() 返回第一个元素的迭代器
end() 返回最末元素的迭代器
rbegin() 返回尾部的逆迭代器
rend() 返回起始的逆迭代器 

访问元素

d.at(i)	//返回指定位置的元素
d[i]	//返回指定位置的元素
d.back() //返回最末一个元素
d.front() //返回第一个元素 

插入与删除元素

void push_back( const TYPE &val ); //在最后添加一个元素
void pop_back(); //移除最后一个元素
void push_front( const TYPE &val ); //在头部加入一个元素
void pop_front(); //删除头部的元素
iterator erase( iterator loc );	//删除指定loc元素
iterator erase( iterator start, iterator end );	//删除[start,end)元素
iterator emplace( const_iterator pos, Args&&... args );

d.push_back(3);	//最后添加元素3
d.pop_back();	//删除最后一个元素
d.push_front(1)	//首元素添加元素1
d.pop_front();	//删除首元素
d.erase(d.begin());//删除位置为begin的元素
d.erase(d.begin(),d.end());//删除区间[begin(),end())的元素

insert函数

//在位置为pos插入元素val
iterator insert( iterator pos, const TYPE &val );
//在位置为pos插入num个值为val元素
iterator insert( iterator pos, size_type num, const TYPE &val );
//在位置pos插入区间[start,end)
void insert( iterator pos, input_iterator start, input_iterator end );

//在begin位置插入元素1
d.insert(d.begin(),1);
//在begin位置插入5个值为1的元素
d.insert(d.begin(),5,1);
//在begin插入区间[d2.begin(),d2.end())
d.insert(d.begin(),d2.begin(),d2.end());

queue

queue 是STL提供的队列容器

TYPE &back(); //返回最后一个元素
bool empty();	//如果队列空则返回真
TYPE &front() 返回第一个元素
TYPE &pop() 删除第一个元素
void push( const TYPE &val );在末尾加入一个元素 

功能就和普通的队列相同

Priority Queues(优先队列)

优先队列类似队列,但是在这个数据结构中的元素按照一定的断言排列有序

priority_queue<Type>
priority_queue<Type, Container, Functional>
其中Type 为数据类型, Container 为保存数据的容器,Functional 为元素比较方式。
Container 这里保存的容器一般用vector和deque

priority_queue<int> q;	//排序顺序默认为降序,也就是创建了大顶堆
priority_queue<int,vector<int>,less<int>> q;	//排序顺序为升序,创建了小顶堆

优先级队列,这个容器可以用set来实现。

stact

该容器与现实数据结构stack相同

bool empty() 	//堆栈为空则返回真
void pop(); 	//移除栈顶元素
void push( const TYPE &val ); //在栈顶增加元素
size_type size(); 	//返回栈中元素数目
TYPE &top(); 	//返回栈顶元素 

list

List将元素按顺序储存在链表中. 与 vector相比, 它允许快速的插入和删除,但是随机访问却比较慢

构造函数

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

list<int>L;	//空的list容器
list<int>L2(5);//大小为5值为0的容器
list<int>L3(5,1);//大小为5值为1的容器
list<int>L4(L3);//用L3创建容器
list<int>L5 = {1,4,6,8,4};//初始化容器

迭代器iterator

iterator begin();	//返回指向第一个元素的迭代器
iterator end()		//返回末尾的迭代器
iterator rbegin()	//返回指向第一个元素的逆向迭代器
iterator rend()		//返回list末尾的逆向迭代器

访问元素

L.back() //返回最末一个元素
L.front() //返回第一个元素 

插入与删除元素

void push_back( const TYPE &val ); //在最后添加一个元素
void pop_back(); //移除最后一个元素
void push_front( const TYPE &val ); //在头部加入一个元素
void pop_front(); //删除头部的元素
iterator erase( iterator loc );	//删除指定loc元素
iterator erase( iterator start, iterator end );	//删除[start,end)元素
void remove( const TYPE &val );	//删除所有的指定元素
void remove_if( UnPred pr );//以一元谓词pr为判断元素的依据,遍历整个链表。如果pr返回true则删除该元素
L.push_back(3);	//最后添加元素3
L.pop_back();	//删除最后一个元素
L.push_front(1)	//首元素添加元素1
L.pop_front();	//删除首元素
L.erase(d.begin());//删除位置为begin的元素
L.erase(d.begin(),d.end());//删除区间[begin(),end())的元素
L.remove(1);	//删除元素1
L.remove_if([](int n) { return n > 4; });	//删除大于4的元素

insert函数

//在位置为pos插入元素val
iterator insert( iterator pos, const TYPE &val );
//在位置为pos插入num个值为val元素
iterator insert( iterator pos, size_type num, const TYPE &val );
//在位置pos插入区间[start,end)
void insert( iterator pos, input_iterator start, input_iterator end );

//在begin位置插入元素1
L.insert(L.begin(),1);
//在begin位置插入5个值为1的元素
L.insert(L.begin(),5,1);
//在begin插入区间[L2.begin(),L2.end())
L.insert(L.begin(),L2.begin(),L2.end());

合并链表

merge()合并两个list,要求两个list必须有序;
splice()不需要list有序,splice()不复制或移动元素,仅重指向链表结点的内部指针
可以用advance调整iterator 的位置

void merge( list &lst );	//合并两个list必须有序,默认是升序,被合并list会被清空
void merge( list &lst, Comp compfunction );	//合并两个list,按照指定的顺序排序
void splice( iterator pos, list &lst );	//将lst指向pos位置
void splice( iterator pos, list &lst, iterator del );	//将lst中del指向pos
void splice( iterator pos, list &lst, iterator start, iterator end );//将lst区间start与end元素指向pos

L.merge(L2);	//将L2合并到L
L.merge(L2,Compare);	//将L2合并到L,指定Compare规则
L.splie(L.begin(),L2);	//将L2整个list指向L.begin()位置
L.splie(L.begin(),L2,L2.begin());	//从L2的迭代器L2.begin()开始指向L.begin()位置
L.splie(L.begin(),L2,L2.begin(),L2.end());	//将L2的迭代器区间[L2.begin(),L2.end())指向L的迭代器L.begin()位置

set

set容器的底层是由二叉树构成。set在插入元素时,是不允许插入重复元素的;multiset是允许插入重复元素的。set会自动排序,默认是升序。

构造函数

set中不存在set s(size_type num,T val)。因为set不允许重复元素。

iterator begin();	//返回指向第一个元素的迭代器
iterator end()		//返回末尾的迭代器
iterator rbegin()	//返回指向第一个元素的逆向迭代器
iterator rend()		//返回末尾的逆向迭代器
iterator lower_bound()	//返回指向大于(或等于)某值的第一个元素的迭代器
iterator upper_bound()	//返回大于某个值元素的迭代器

可以使用set<T,Compare>指定排序规则。

迭代器iterator

iterator begin();	//返回指向第一个元素的迭代器
iterator end()		//返回末尾的迭代器
iterator rbegin()	//返回指向第一个元素的逆向迭代器
iterator rend()		//返回末尾的逆向迭代器
iterator lower_bound()	//返回指向大于(或等于)某值的第一个元素的迭代器
iterator upper_bound()	//返回大于某个值元素的迭代器

插入与删除元素

iterator begin();	//返回指向第一个元素的迭代器
iterator end()		//返回末尾的迭代器
iterator rbegin()	//返回指向第一个元素的逆向迭代器
iterator rend()		//返回末尾的逆向迭代器
iterator lower_bound()	//返回指向大于(或等于)某值的第一个元素的迭代器
iterator upper_bound()	//返回大于某个值元素的迭代器

unordered_set

unordered_set 容器,为“无序 set 容器”。即 unordered_set 容器和 set 容器很像,唯一的区别就在于 set 容器会自行对存储的数据进行排序,而 unordered_set 容器不会

	unordered_set<int>s;
	s.insert(10);
	s.insert(60);
	s.insert(30);
	s.insert(90);
	for (auto a : s) {
		cout << a<< endl;
	}
--------------------------
90
10
60
30

map

map 是有序键值对容器,默认是升序,它的元素的键是唯一的。用比较函数 Compare 排序键。 map 通常实现为红黑树。mutlimap是允许存储重复元素。

构造函数

set中不存在map s(size_type num,T val)。因为set不允许重复元素。

map<T>m; //采用模板类实现对象的默认构造形式:
map<T>m(const map& ml); //拷贝函数,将s初始化为se一样
map<T>m(iterator start,iterator end)	//将s的初始化为[start,end)区间

map<int>m1;
map<int>m2(m);
map<int>m3(m.begin(),m.end());

可以使用map<T1,T2,Compare>指定排序规则。

迭代器iterator

iterator begin();	//返回指向第一个元素的迭代器
iterator end()		//返回末尾的迭代器
iterator rbegin()	//返回指向第一个元素的逆向迭代器
iterator rend()		//返回末尾的逆向迭代器
iterator lower_bound()	//返回指向大于(或等于)某值的第一个元素的迭代器
iterator upper_bound()	//返回大于某个值元素的迭代器

插入与删除元素

iterator insert(const pair &p); //在集合中插入元素
void insert( input_iterator start, input_iterator end );//插入区间[start,end)元素

void erase( iterator i );	//删除i的元素
void erase( iterator start, iterator end );		//删除区间[start,end)中的元素
size_type erase( const key_type &key );		//删除指定元素值

m.insert(make_pair(1,10));	//插入pair(1,10)
m.insert(s2.begin(),s2,end());	//插入区间[begin,end)元素

m.erase(m.begin());	//删除元素为begin()中的元素
m.erase(m.begin(),m.end());	//删除区间[begin,end)的元素
m.erase(1);		//删除key为1的pair

find()与count()

//返回一个迭代器指向键值为key的元素,如果没找到就返回指向map尾部的迭代器
iterator find( const KEY_TYPE &key );
//还回map中键值等于key的元素的个数。map只会返回0、1,mutlimap会返回值的个数
size_type count( const KEY_TYPE &key );
map<int ,int>::iterator it=m.find(10) //在m中查找key为10的元素
int num=m.count(10);	//查找key为10的值

unordered_map

unordered_map与map的用法基本一直,最大的区别在于:
map的key是有序的,而unordered_map的key为无序。

#include<unordered_map>
int main() {
	unordered_map<int, int>m;
	m.insert(make_pair(1, 10));
	m.insert(make_pair(1, 20));//key相同是不会重复存储的
	m.insert(make_pair(6, 20));
	m.insert(make_pair(3, 30));
	m.insert(make_pair(9, 50));
	for (auto a : m) {
		cout << a.first << endl;
	}
	return 0;
}
-----------------------------
9
1
6
3

unordered_map与unordered_set的存储时按照散列表存储的,输出顺序与输入顺序是不一定相同的

到此这篇关于C++中的各种容器的使用方法的文章就介绍到这了,更多相关C++容器使用内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • C++ vector容器 find erase的使用操作:查找并删除指定元素

    概念:容器.迭代器.算法 STL包括容器.迭代器和算法: 容器 用于管理一些相关的数据类型.每种容器都有它的优缺点,不同的容器反映出程序设计的不同需求.容器自身可能由数组或链表实现,或者容器中的每个元素都有特殊的关键值. 迭代器 用于遍历一个数据集中的每个元素.这些数据集可能是容器或者容器的子集.迭代器的主要优点是它们为任意类型的容器提供一个小巧并且通用(注意通用很重要)的接口.例如,迭代器接口的一个操作是让它依次遍历数据集的每个元素.这个操作是依赖容器的内总部结构独立完成的.迭代器之所以有效是

  • C++顺序容器(vector、deque、list)的使用详解

    目录 一:STL(Standard Template Library),即标准模板库,是一个高效的C++程序库 二:STL组件 三:容器 四:类型成员 五:迭代器 六:顺序容器 七:顺序容器--向量(vector) 八:顺序容器--双端队列--deque 九:顺序容器 --列表--list 一:STL(Standard Template Library),即标准模板库,是一个高效的C++程序库 1.从实现层次看,整个STL是以一种类型参数化(type parameterized)的方式实现的,基

  • C++ 容器 Vector 的使用方法

    目录 Vector简介 Vector 与数组 创建 vector 的各种方法 访问 vector 的元素 删除元素 前言: 我们都是带着问题学习,假设一个任务,也可以理解为一个问题,通过找解决方案来提升自己 c++ 的编程能力,尝试这是否一条好的路线,希望找到这种学习方式有效 问题简单描述一下,就是从以字符串,课程名称组成的集合中将一些包含特定文字,将其从列表中删除 Vector简介 Vector 是一个能够存放任意类型的动态数组,有点类似数组,是一个连续地址空间, Vector 与数组 Vec

  • C++深入分析STL中map容器的使用

    目录 1.map容器 2.map容器原理 3.map容器函数接口 4.使用示例 1.map容器 map是C++ STL的一个关联容器,它提供一对一的数据处理能力.其中,各个键值对的键和值可以是任意数据类型,包括 C++ 基本数据类型(int.double 等).使用结构体或类自定义的类型. 第一个可以称为关键字(key): 第二个可能称为该关键字的值(value): 该容器存储的都是 pair<const K, T> 类型(其中 K 和 T 分别表示键和值的数据类型)的键值对元素. 使用 ma

  • javaweb中静态文件的常用处理方法汇总

    本文实例汇总了javaweb中静态文件的常用处理方法,在Javaweb程序开发中很有实用价值,具体方法汇总如下: 方法一:激活Tomcat的defaultServlet来处理静态文件 在web.xml中添加: <servlet-mapping> <servlet-name>default</servlet-name> <url-pattern>*.jpg</url-pattern> </servlet-mapping> <ser

  • Java中常用修饰符的使用方法汇总

    修饰符汇总: 一:public protected default private 修饰类,修饰方法,修饰属性,修饰代码块. 类: 顶级类只能用public 修饰,顶级类不能使用private 和protected 修饰. 外部类可以被public修饰或者默认不写,不能用private和protected. 内部类可为静态,可用protected和private修饰. 方法: 通常方法可以被四个访问修饰符修饰,构造方法也可以被四个访问修饰符修饰. 抽象类中的抽象方法不能被private修饰,可以

  • JavaScript 中Date对象的格式化代码方法汇总

    JavaScript默认的时间格式我们一般情况下不会用,所以需要进行格式化,下面说说我总结的JavaScript时间格式化方法. 很多时候,我们可以利用JavaScript中Date对象的内置方法来格式化,如: var d = new Date(); console.log(d); // 输出:Mon Nov 04 2013 21:50:33 GMT+0800 (中国标准时间) console.log(d.toDateString()); // 日期字符串,输出:Mon Nov 04 2013

  • Android中隐藏状态栏和标题栏的方法汇总(隐藏状态栏、标题栏的五种方法)

      方法一: public class MainActivity extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); // 隐藏标题栏 requestWindowFeature(Window.FEATURE_NO_TITLE); // 隐藏状态栏 getWindow().setFlags(WindowManager

  • Javascript获取数组中的最大值和最小值的方法汇总

    比较数组中数值的大小是比较常见的操作,比较大小的方法有多种,比如可以使用自带的sort()函数,下面来介绍如下几种方法,代码如下: 方法一: //最小值 Array.prototype.min = function() { var min = this[0]; var len = this.length; for (var i = 1; i < len; i++){ if (this[i] < min){ min = this[i]; } } return min; } //最大值 Array

  • SpringBoot中时间格式化的五种方法汇总

    目录 前言 时间问题演示 1.前端时间格式化 JS 版时间格式化 2.SimpleDateFormat格式化 3.DateTimeFormatter格式化 4.全局时间格式化 实现原理分析 5.部分时间格式化 总结 参考 & 鸣谢 前言 在我们日常工作中,时间格式化是一件经常遇到的事儿,所以本文我们就来盘点一下 Spring Boot 中时间格式化的几种方法. 时间问题演示 为了方便演示,我写了一个简单 Spring Boot 项目,其中数据库中包含了一张 userinfo 表,它的组成结构和数

  • JavaScript中常用的几种字符串方法汇总(新手必看)

    JavaScript常用的几种字符串方法 字符串是一种只读数据,只能查 常用的几种字符串方法: 1.charAt:根据指定的下标获取到对应的字符; 2.charCodeAt:根据指定的下标获取到字符对应的阿斯克码:(底部有ASCII对照表) ps:通过阿斯克码获取到字符: 3.substring:截取字符串: 4.substr:截取字符串: 5.slice:截取字符串: 6.indexOf:查找字符/子字符串在大字符串中第一次出现的位置,找到了返回下标,找不到返回-1: 7.lastIndexO

  • Oracle中插入特殊字符:&和'的解决方法汇总

    今天在导入一批数据到Oracle时,碰到了这样一个问题:Toad提示要给一个自定义变量AMP赋值,一开始我很纳闷,数据是一系列的Insert语句,怎么会有自定义变量呢?后来搜索了一下关键字AMP发现,原来是因为在插入数据中有一个字段的内容如下: http://xxx.com/3DX?uid=0676&sid=rt_060908 Oracle把这里的URL的参数连接符&当成是一个自定义变量了,所以要求我给变量AMP赋值.经过测试之后,总结出以下三种方法: 方法一:在要插入的SQL语句前加上S

  • C#中DateTime日期类型格式化显示方法汇总

    本文汇总了常用的DateTime日期类型格式化显示方法,方便读者在使用的时候参考借鉴一下.具体如下所示: 1.绑定时格式化日期方法: <ASP:BOUNDCOLUMN DATAFIELD= "JoinTime " DATAFORMATSTRING= "{0:yyyy-MM-dd} " > <ITEMSTYLE WIDTH= "18% " > </ITEMSTYLE > </ASP:BOUNDCOLUMN

  • 在JS方法中返回多个值的方法汇总

    在使用JS编程中,有时需要在一个方法返回两个个或两个以上的数据,用下面的几种方法都可以实现: 1 使用数组的方式,如下: <html> <head> <title>JS函数返回多个值</title> </head> <body> <input type="button" onclick="getNames()" value="test" /> <script

随机推荐

其他