STL容器的常用用法

最新推荐文章于 2022-11-28 21:52:36 发布
最新推荐文章于 2022-11-28 21:52:36 发布
阅读量316 收藏 2
点赞数
分类专栏： 编程语言 文章标签： C++ STL vector

 

STL容器的常用用法

目录

 

Top

STL：

1.vector：

vector<int> v;
vector<int> v(10);//定义大小为10的int型向量容器。
vector<int> v(10,3);//定义大小为10，每个元素为3。

v.push_back(2);//尾部添加元素2.

v.pop_back();//尾部删除一个元素.

v[0]=2;
v[1]=3;//下标访问。

vector<int>::iterator it;//迭代器访问
for(it=v.begin();it!=v.end();it++)
{
cout<<*it<<" ";
}

//元素插入，插入位置必须是迭代器位置
v.insert(v.begin(),8);//最前面插入
v.insert(v.begin()+2,8);
v.insert(v.end(),8);//末尾追加

//元素删除
v.erase(v.begin()+2);//删除第2+1个元素
v.erase(v.begin()+1,v.begin()+5);//删除迭代器第一到第五区间的所有元素
v.clear();//删除所有元素

reverse(v.begin(),v.end());//反向排列向量所有元素（可以反向排列某段迭代器区间元素）

sort(v.begin(),v.end());//sort排序（默认升序排列）

//设计排序比较函数
bool comp(const int& a,const int& b)
{
return a>b;//降序排列
}
sort(v.begin(),v.end(),comp);

v.size();//返回向量大小,即元素个数
v.empty();//判空，空时返回1，不空时返回0。

#include<vector>  
#include<iostream>  
using namespace std;  
 
int main()  
{  
    vector<int> v(3);  
    v[0]=2; //v[0]是第0个元素 
    v[1]=7;  
    v[2]=9;  
    v.insert(v.begin(),8);//在最前面插入新元素。  
    v.insert(v.begin()+2,1);//在迭代器中第二个元素前插入新元素  
    v.insert(v.end(),3);//在向量末尾追加新元素。  
 
	v.insert(v.end(),4,1);//在尾部插入4个1
 
	int a[] = {1,2,3,4};
	v.insert(v.end(),a[1],a[3]);//在尾部插入a[1]个a[3]
 
    vector<int>::iterator it;  
    for(it=v.begin(); it!=v.end();it++)  
    {  
        cout<<*it<<" ";  
    }  
    cout<<endl;
 
	return 0;
}  
 
//8 2 1 7 9 3 1 1 1 1 4 4
//请按任意键继续. . .

 

  STL中的容器按存储方式分为两类，一类是按以数组形式存储的容器（如：vector 、deque)；另一类是以不连续的节点形式存储的容器（如：list、set、map）。在使用erase方法来删除元素时，需要注意一些问题。
      在使用 list、set 或 map遍历删除某些元素时可以这样使用：

正确使用方法1      

      std::list< int> List;
      std::list< int>::iterator itList;
      for( itList = List.begin(); itList != List.end(); )
      {
            if( WillDelete( *itList) )
            {
               itList = List.erase( itList);
            }
            else
               itList++;
      }
       或
正确使用方法2      

      std::list< int> List;
      std::list< int>::iterator itList;
      for( itList = List.begin(); itList != List.end(); )
      {
            if( WillDelete( *itList) )
            {
               List.erase( itList++);
            }
            else
               itList++;
      }
      
      下面是两个错误的使用方法：

错误使用方法1      

      std::list< int> List;
      std::list< int>::iterator itList;
      for( itList = List.begin(); itList != List.end(); itList++)
      {
            if( WillDelete( *itList) )
            {
               List.erase( itList);
            }
      }


         或

错误使用方法2      

      std::list< int> List;
      std::list< int>::iterator itList;
      for( itList = List.begin(); itList != List.end(); )
      {
            if( WillDelete( *itList) )
            {
               itList = List.erase( ++itList);
            }
            else
               itList++;
      }


      正确使用方法1：通过erase方法的返回值来获取下一个元素的位置
      正确使用方法2：在调用erase方法之前先使用 “++”来获取下一个元素的位置
      错误使用方法1：在调用erase方法之后使用“++”来获取下一个元素的位置，由于在调用erase方法以后，该元素的位置已经被删除，如果在根据这个旧的位置来获取下一个位置，则会出现异常。
      错误使用方法2：同上。

      这里“++”运算符与我们平常的理解刚好相反，erase( itList++) 是先获取下一个元素的位置在删除； erase( ++itList) 是删除以后再获取下一个元素的位置。

     在使用 vector、deque遍历删除元素时，也可以通过erase的返回值来获取下一个元素的位置：

正确使用方法      

      std::vector< int> Vec;
      std::vector< int>::iterator itVec;
      for( itVec = Vec.begin(); itVec != Vec.end(); )
      {
            if( WillDelete( *itVec) )
            {
                 itVec = Vec.erase( itVec);
            }
            else
               itList++;
      }

      
      注意：vector、deque 不能像上面的“正确使用方法2”的办法来遍历删除。

2.stack：

//堆栈容器

stack<int> s;
s.push(1);//入栈
s.pop();//出栈
s.top();//返回栈顶元素
s.size();//返回元素个数
s.empty();//判空

3.queue：

//队列容器
//只能从队尾插入元素，队首删除元素
queue<int> q;
q.push(1);//入队
q.pop();//出队
q.front();//返回队首元素
q.back();//返回队尾元素
q.size();//返回元素个数
q.empty();//判空

4.priority_queue：

//优先队列容器
//只能从队尾插入元素，队首删除元素
//队列中最大的元素总是位于队首（默认从大到小排序，自己可以自定义比较函数来修改）

priority_queue<int> pq;
pq.push(1);//入队
pq.pop();//出队
pq.top();//返回队首元素
pq.size();//返回元素个数
pq.empty();//判空

//自定义比较函数
元素为结构体：
struct info
{
string name;
float score;
bool operator < (const info &a) const
{
return score>a.score;//从小到大（注意这次的符号）
}
}；

元素非结构体：
struct mycomp
{
bool operator () (const int &a,const int &b) const
{
return a>b;//从小到大（注意这次的符号）
}
};
priority_queue<int,vector<int>,mycomp> pq;//显示说明其内部结构是vector.（注意：当有自定义比较函数时，必须显示说明其内部结构是vector！）

5.deque：

创建
deque<int> d;
deque<int> d(10);//容量为10
deque<int> d(10,8.5);//10个并初始化为8.5

插入：
push_back()尾部插入，扩张队列
push_front()头部插入，不扩张队列，往后挤，把尾部的元素挤出去了
以上两个参数是一个元素对象
insert()中间某位置插入元素，不扩张队列，仍是挤出尾部的元素
参数为两个：迭代器位置+元素对象
eg：d.insert(d.begin()+1,88);//即插入到第二个位置，后面的往后顺延，最后一个丢失

遍历：
d[i]//数组方式

deque<int>::iterator it;
for(it=d.begin();it!=d.end();it++)
{
cout<<*it<<" ";
}//前向迭代器方式

deque<int>::reverse_iterator it;
for(rit=d.rbegin();rit!=d.rend();rit++)
{
cout<<*rit<<" ";
}//反向迭代器方式

删除：
首部：d.pop_front();
尾部：d.pop_back();
中间：d.erase(d.begin()+1);
清空：d.clear();

6.set：

#include <set>
#include <algorithm>

//不会重复插入相同键值的元素
//采用红黑树的平衡二叉检索树结构，中序遍历

set<int> s;

s.insert(3);//默认从小到大

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

//反向遍历
set<int>::reverse_iterator rit;//反向迭代器
for(rit=s.rbegin();rit!=s.rend();rit++)
{
cout<<*rit<<" ";
}

//元素删除，删除对象可以是某个迭代器位置上的元素、等于某键值的元素、一个区间上的元素
s.erase(s.begin()+1);
s.erase(6);
s.erase(s.begin(),s.begin()+4);
s.clear();

s.size();

s.find(6);//查找键值6，查到了则返回其迭代器位置，否则返回最后一个元素后面的位置，即end()
set<int>::iterator it;
it=s.find(6);
if(it!=s.end())
cout<<*it<<endl;

//自定义比较函数 默认从小到大存储

//非结构体元素
struct comp
{
bool operator () (const int& a,const int& b) const
{
return a>b;//从大到小
}
}
set<int,comp> s;//创建
set<int,comp>::iterator it;
其他操作一样


//结构体元素
struct info
{
string name;
float score;
bool operator < (const info &a) const
{
return score>a.score;//从大到小
}
}
set<info> s;//创建
set<info>::iterator it;

7.multiset：

#include <set>
#include <algorithm>

//允许重复的元素键值插入

//在插入，删除，查找方面与<set>有区别

multiset<string> ms;
ms.insert("abc");
multiset<string>::iterator it;

//erase()可以删除某个迭代器位置的元素，某段区间的元素，键值等于某个值的所有重复元素（并返回删除元素个数）。
ms.erase("123");
ms.clear();

//find()，如果查到，返回该元素第一次出现的迭代器位置，否则返回end()
it=ms.find("123");

8.map：

#include <map>
#include <algorithm>

//不会重复插入相同键值的元素
//采用红黑树的平衡二叉检索树结构，中序遍历
//比较函数只对键值进行比较
//和set使用大都相同

map<string,float> m;
m["jack"]=98.5;//插入元素
m.insert(pair<string,float>("lvhuan",18.5));

map<string,float>::iterator it;
for(it=m.begin();it!=m.end();it++)
{
cout<<(*it).first<<":"<<(*it).second<<endl;//输出键值与映照数据
}

//可以删除某个迭代器位置元素、等于某键值的元素、某迭代器区间的所有元素
m.erase(4);
m.clear();

//反向遍历
map<string,float>::reverse_iterator it;
for(it=m.rbegin();it!=m.rend();it++)
{
cout<<(*it).first<<":"<<(*it).second<<endl;//反向输出键值与映照数据
}

//find()返回键值所处迭代器位置或end()位置

//自定义比较函数（默认从小到大）
非结构体元素
struct comp
{
bool operator () (const int &a,const int &b) const
{
return a>b;//从大到小
}
}
map<int,char,comp> m;
map<int,char,comp>::iterator it;

结构体元素
struct info
{
string name;
float score;
bool operator < (const info &a) const
{
return score>a.score;//从大到小
}
}
map<info,int> m;//创建
map<info,int>::iterator it;
for(it=m.begin();it!=m.end();it++)
{
cout<<(*it).second<<":";
cout<<((*it).first).name<<" "<<((*it).first).score<<endl;
}

9.multimap：

#include <map>
#include <algorithm>

//允许重复插入相同键值的元素

multimap<string,float> m;
m["jack"]=98.5;//插入元素
m.insert(pair<string,float>("lvhuan",18.5));

multimap<string,float>::iterator it;
for(it=m.begin();it!=m.end();it++)
{
cout<<(*it).first<<":"<<(*it).second<<endl;//输出键值与映照数据
}

//erase()可以删除某个迭代器位置的元素，某段区间的元素，键值等于某个值的所有重复元素（并返回删除元素个数），还有清空clear()

//find()，如果查到，返回该元素第一次出现的迭代器位置，否则返回end()
it=m.find("123");

10.list：

//双向循环链表容器

//迭代器只能使用“++”或“--”，不能使用“+n”或“-n”。

创建：
list<int> l;
list<int> l(10);//容量10

插入，都会自动扩张：
尾部：push_back()
首部：push_front()
中间：只能插到迭代器位置处：l.insert(it,20);//元素对象为20

遍历：
list<int>::iterator it;
for(it=l.begin();it!=l.end();it++)
{
cout<<*it<<" ";
}//前向迭代器方式

list<int>::reverse_iterator it;
for(rit=l.rbegin();rit!=l.rend();rit++)
{
cout<<*rit<<" ";
}//反向迭代器方式

删除：remove()删除一个元素值，值相同的元素都会被删除。
l.remove(1);//删除值为1的所有元素

l.pop_front();//删除首部元素
l.pop_back();//删除链表尾部元素

list<int>::iterator it;
for(it=l.begin();it!=l.end();it++)
{
cout<<*it<<" ";
}
it=l.begin();
it++;
it++;
l.erase(it);//删除迭代器位置元素

l.clear();//清空

查找：find()，找到则返回迭代器位置，否则返回end().
eg:it=find(l.begin(),l.end(),5);//查找这个区间上的值为5的元素的位置

升序排序：
l.sort();

删除连续重复元素,只保留一个：
l.unique();//注意是删除连续重复，不是单单重复

11.bitset：

//bit位元素的序列容器，每个元素只占一个bit位，取值0或1.

/*
bitset类
方法列表：
b.any() b中是否存在置为1的二进制位？
b.none() b中不存在置为1的二进制位吗？
b.count() b中置为1的二进制位的个数
b.size() b中二进制位的个数
b[pos] 访问b中在pos处的二进制位
b.test(pos) b中在pos处的二进制位是否为1？
b.set() 把b中所有二进制位都置为1
b.set(pos) 把b中在pos处的二进制位置为1
b.reset() 把b中所有二进制位都置为0
b.reset(pos) 把pos处的二进制位置为0
b.flip() 把b中所有二进制位取反
b.flip(pos) 把pos处的二进制位取反
b.to_ulong() 用b中同样的二进制位返回一个unsigned long值
os<<b 把b中的位集输出到os流
*/

//创建
bitset<100000> b;//创建时必须指定容器大小，且不能再修改大小。默认初始值为0.

//元素赋值
b[6]=1;//下标法，最低位为第0位
b.set();//全部置1
b.set(6);//将指定位置1
b.reset();//全部置0
b.reset(6);//指定位置0

//输出元素
cout<<b[i];//下标法输出，可以借用b.size()来控制个大规模输出
cout<<b;//注意输出的可是二进制形式哦（01串）

转自

https://www.cnblogs.com/jiu0821/p/4190026.htm

https://blog.csdn.net/u010002184/article/details/77676638

http://www.cppblog.com/Herbert/archive/2008/12/27/70479.html

fason_z
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
STL常用容器用法大全
星夜不语秋声
01-26 2176
STL容器常见用法集合
代码随想录终极总结之_STL容器使用
muzi_taibai的博客
04-04 419
代码随想录终极总结之_STL容器使用
stl容器的介绍及使用
qq_69969929的博客
10-05 736
stl容器的简单介绍及操作方法介绍
STL核心知识总结（1）常用容器的用法
阿东的学习记录
02-06 1612
目 录stringvectordeque容器stackqueuelistset/ multisetmap/ multimap Tips： 在使用容器时，注意要添加相应的头文件，如#include<string>； STL的学习过程本质上就是学习数据结构与算法的过程，使用C++语言将常见的数据结构类型实现出来； 各个容器包含的操作大同小异，一通百通。 string string是一个类，类内部封装了char*，管理这个字符串，是一个char*型的容器。 构造函数 string s1;
算法基础(三)——STL容器的简单使用
m0_50203796的博客
08-04 639
简要列举主要的STL使用方法并且提供了几个使用容器的算法题
C++ STL容器stack和queue详解
01-20
stack是一个比较简单的容器，它的使用也很简单，stack是LIFO容器，就是后进先出，最后添加进去的元素，第一个取出来 stack初始化 std::stack<int> first; std::stack<int> second(first); std::stack<int>> third...
C++STL实验报告-容器的使用（2）
最新发布
12-30
实验目的的： 本实验主要练习容器link、队列、栈、优先队列、bitset的使用方法。...回顾以上容器常用函数的使用方法。 二．练习课本第7章的例7.11-7.27。 三．实验报告应包含例7.14、7.18、7.21、7.22、7.26、7.27。
c++STL基本容器用法带程序详解
03-21
vector用于存储对象数组 常用方法 1.push_back 在数组的最后添加一个数据 2.pop_back 去掉数组的最后一个数据 3.at 得到编号位置的数据 4.begin 得到数组头的指针 5.end 得到数组的最后一个单元+1的指针 6．front ...
STL模板，常用容器.docx
05-09
1，STL的六大组件：容器container，算法algorithm，迭代器iterator，仿函数，适配器（配接器），空间配置器，，容器和算法是通过迭代器进行无缝连接起来的，STL几乎所有代码都采用了模板类或模板函数。 (1).容器：...
C++中STL的基本用法总结
03-02
C++的STL string vector list stack queue set map 等常用的容器使用
C++中STL常用容器的用法详解
m0_60416282的博客
07-04 903
string, vecctor, list, deque, stack, queue, priority_queue、set、map、unorderedset、unorderedmap的使用方法详解
【STL】容器分类及用法(图文+代码详解)
m0_52309496的博客
11-28 1242
STL学习笔记02
stl的中常用几个容器的介绍与特点。
qq_26105397的博客
05-24 3736
&lt;1&gt;vector容器 vector容器是一个动态数组的结构，在内存中有一个指针指向一块连续的内存。类似数组结构一样。它的特点支持随机访问数据，因为其在内存中的单元是连续。如此之外，还可以vector的大小是可以自动增长的。当向一个vector中继续存放数据的时候，如果当前的内存大小不够，内核会重新生成一个是原来两倍的大小的单元，之后 将数据从原先的单元中拷贝至新创建的单元中，...
STL常用容器介绍
qq_36697196的博客
05-06 3534
3.STL常用容器 3.1 string容器 3.1.1 string基本概念 本质： string是C++风格的字符串，而string本质上是一个类 string和char*区别： char*是一个指针 string是一个类，类内部封装了char*，管理这个字符串，是一个char型的容器。 特点： string类内部封装了很多成员方法 例如：查找find、拷贝copy，删除delete 替换replace，插入insert string管理char所分配的内存，不用担心复制越界和取值越界等，由类内部进行
STL容器的适用情况(转)
天地蜉蝣
10-28 776
原文：http://hsw625728.blog.163.com/blog/static/3957072820091116114655254/ vector 典型的序列容器，C++标准严格要求次容器的实现内存必须是连续的，唯一可以和标准C兼容的stl容器，任意元素的读取、修改具有常数时间复杂度，在序列尾部进行插入、删除是常数时间复杂度，但在序
STL- 容器特点总结
肥猫王德福的博客
02-20 1046
STL即C++标准模板库，包含了诸多常用的基本数据结构和基本算法。为广大C++程序员们提供了一个可扩展的应用框架，高度体现了软件的可复用性。 STL包含6大组件+13个头文件。 6大组件： 关于 STL1. 序列式容器2. 关联式容器3. 容器适配器   关于 STL STL即标准模板库（Standard Template Library）。 STL包含 6大组件+13个头文件。   六大组件：容器、算法、迭代器、仿函数、适配器、分配器   这六大组件的交互关系：      contain..
什么是stl? 如何使用stl?
小青龙，创造，变强
04-01 5023
什么是stl? stl如何进行使用？
C++中STL常用容器的优点和缺点
Potter：I am not for learning and learning, but for study and work
03-06 9132
我们常用到的STL容器有vector、list、deque、map、multimap、set和multiset，它们究竟有何区别，各自的优缺点是什么，为了更好的扬长避短，提高程序性能，在使用之前需要我们了解清楚。verctorvector类似于C语言中的数组，它维护一段连续的内存空间，具有固定的起始地址，因而能非常方便地进行随机存取，即 [] 操作符，但因为它的内存区域是连续的，所以在它中间插入或
C++ STL中容器的使用全面总结
热门推荐
算法改变人生
04-19 6万+
一、容器的定义        在数据存储上，有一种对象类型，它可以持有其它对象或指向其它对像的指针，这种对象类型就叫做容器。很简单，容器就是保存其它对象的对象，当然这是一个朴素的理解，这种“对象”还包含了一系列处理“其它对象”的方法。 二、容器的种类   1、顺序容器：是一种各元素之间有顺序关系的线性表，是一种线性结构的可序群集。顺序性容器中的每个元素均有固定的位置，除非用删除或插入的操
stl map容器的常用方法
08-11
下面是`std::map`容器的一些常用方法： 1. 插入元素： ```cpp std::map, Value> myMap; myMap.insert(std::make_pair(key, value)); // 使用insert方法插入键值对 myMap[key] = value; // 使用下标操作符[]插入...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值