STL容器

顺序容器:是一种各元素之间有顺序关系的线性表,是一种线性结构的可序群集。顺序性容器中的每个元素均有固定的位置,除非用删除或插入的操作改变这个位置。顺序容器的元素排列次序与元素值无关,而是由元素添加到容器里的次序决定。

顺序容器包括:vector(向量)、list(列表)、deque(队列)。

容器类自动申请和释放内存,因此无需new和delete操作。

vector

vector是C++标准模板库中的部分内容,它是一个多功能的,能够操作多种数据结构和算法的模板类和函数库。
vector之所以被认为是一个容器,是因为它能够像容器一样存放各种类型的对象,
简单地说,vector是一个能够存放任意类型的动态数组,能够增加和压缩数据。
使用vector,必须在你的头文件中包含下面的代码:

#include <vector>

属于std命名域的,因此需要通过命名限定,如下完成你的代码:

using std::vector;
vector vInts;
或者连在一起,使用全名
std::vector vInts;

初始化

vector                 // 创建一个空的vector。
vector c1(c2)          // 复制一个vector
vector c(n)            // 创建一个vector,含有n个数据,数据均已缺省构造产生
vector c(n, elem)      // 创建一个含有n个elem拷贝的vector
vector c(beg,end)      // 创建一个含有n个elem拷贝的vector

析构函数

c.~vector ()           // 销毁所有数据,释放内存

成员函数

c.begin()          // 传回迭代器中的第一个数据地址。
c.end()            // 指向迭代器中末端元素的下一个,指向一个不存在元素。
c.push_back(elem)  // 在尾部加入一个数据。
c.clear()          // 移除容器中所有数据。
c.empty()          // 判断容器是否为空。
c.size()           // 返回容器中实际数据的个数。
c1.swap(c2)        // 将c1和c2元素互换。
swap(c1,c2)        // 将c1和c2元素互换。同上操作。
c.capacity()       // 返回容器中数据个数。
operator[]         // 返回容器中指定位置的一个引用。
c.max_size()       // 返回容器中最大数据的数量。
----------------------------------------------------------------------------------------
c.front()             // 传回第一个数据。
c.back()              // 传回最后一个数据,不检查这个数据是否存在。
c.assign(beg,end)c.assign(n,elem)//将[beg; end)区间中的数据赋值给c。将n个elem的拷贝赋值给c。
c.at(idx)             //传回索引idx所指的数据,如果idx越界,抛出out_of_range。
c.erase(pos)          // 删除pos位置的数据,传回下一个数据的位置。
c.erase(beg,end)      //删除[beg,end)区间的数据,传回下一个数据的位置。
get_allocator         // 使用构造函数返回一个拷贝。
c.insert(pos,elem)    // 在pos位置插入一个elem拷贝,传回新数据位置。
c.insert(pos,n,elem)  // 在pos位置插入n个elem数据。无返回值。
c.insert(pos,beg,end) // 在pos位置插入在[beg,end)区间的数据。无返回值。 
c.pop_back()          // 删除最后一个数据。
c.rbegin()            // 传回一个逆向队列的第一个数据。
c.rend()              // 传回一个逆向队列的最后一个数据的下一个位置。
c.resize(num)         // 重新指定队列的长度。
c.reserve()           // 保留适当的容量。

list

List定义

List是stl实现的双向链表,与向量(vectors)相比, 它允许快速的插入和删除,但是随机访问却比较慢。使用时需要添加头文件

#include <list>

List初始化

list<int>lst1;                           //创建空list
list<int> lst2(5);                       //创建含有5个元素的list
list<int>lst3(3,2);                      //创建含有3个元素的list
list<int>lst4(lst2);                     //使用lst2初始化lst4
list<int>lst5(lst2.begin(),lst2.end());  //同lst4

List常用操作函数

Lst1.push_back()      //在list的末尾添加一个元素 
Lst1.push_front()     //在list的头部添加一个元素 
Lst1.clear()          //删除所有元素 
----------------------------------------------------
Lst1.assign()         //给list赋值 
Lst1.back()           //返回最后一个元素 
Lst1.begin()          //返回指向第一个元素的迭代器 
Lst1.empty()          //如果list是空的则返回true 
Lst1.end()            //返回末尾的迭代器 
Lst1.erase()          //删除一个元素 
Lst1.front()          //返回第一个元素 
Lst1.get_allocator()  //返回list的配置器 
Lst1.insert()         //插入一个元素到list中 
Lst1.max_size()       //返回list能容纳的最大元素数量 
Lst1.merge()          //合并两个list 
Lst1.pop_back()       //删除最后一个元素 
Lst1.pop_front()      //删除第一个元素 
Lst1.rbegin()         //返回指向第一个元素的逆向迭代器 
Lst1.remove()         //从list删除元素 
Lst1.remove_if()      //按指定条件删除元素 
Lst1.rend()           //指向list末尾的逆向迭代器 
Lst1.resize()         //改变list的大小 
Lst1.reverse()        //把list的元素倒转 
Lst1.size()           //返回list中的元素个数 
Lst1.sort()           //给list排序 
Lst1.splice()         //合并两个list 
Lst1.swap()           //交换两个list 
Lst1.unique()         //删除list中重复的元素

deque

#include <deque>

deque容器类与vector类似,支持随机访问和快速插入删除,它在容器中某一位置上的操作所花费的是线性时间。与vector不同的是,deque还支持从开始端插入数据:push_front()。其余类似vector操作方法的使用。

顺序容器通用方法

添加元素

c.push_back(t)  	//在容器c的尾部添加值为t的元素。返回void 类型
c.push_front(t) 	//在容器c的前端添加值为t的元素。返回void 类型只适用于list和deque容器类型。
c.insert(p,t)   	//在迭代器p所指向的元素前面插入值为t的新元素。返回指向新添加元素的迭代器。
c.insert(p,n,t) 	//在迭代器p所指向的元素前面插入n个值为t的新元素。返回void 类型
c.insert(p,b,e) 	//在迭代器p所指向的元素前面插入由迭代器b和e标记的范围内的元素。返回 void 类型

容器大小操作

c.size()       //返回容器c中元素个数。返回类型为 c::size_type
c.max_size()   //返回容器c可容纳的最多元素个数,返回类型为c::size_type
c.empty()      //返回标记容器大小是否为0的布尔值
c.resize(n)    //调整容器c的长度大小,使其能容纳n个元素,如果n<c.size(),则删除多出来的元素。
c.resize(n,t)  //调整容器c的长度大小,使其能容纳n个元素。所有新添加的元素值都为t

访问元素

c.back()        //返回容器 c 的最后一个元素的引用。如果 c 为空,则该操作未定义
c.front()       //返回容器 c 的第一个元素的引用。如果 c 为空,则该操作未定义
c[n]            //返回下标为 n 的元素的引用。如果下标越界,则该操作未定义只适用于 vector 和 deque 容器
c.at(n)         //返回下标为 n 的元素的引用。如果下标越界,则该操作未定义只适用于 vector 和 deque 容器

删除元素

c.erase(p)    //删除迭代器p所指向的元素。返回一个迭代器,它指向被删除元素后面的元素。
c.erase(b,e)  //删除迭代器b和e所标记的范围内所有的元素。返回一个迭代器,它指向被删除元素段后面的元素。
c.clear()     //删除容器c内的所有元素。返回void。
c.pop_back()  //删除容器c的最后一个元素。返回void。如果c为空容器,则该函数未定义。
c.pop_front() //删除容器c的第一个元素。返回void。如果c为空容器,则该函数未定义只适用于list或deque容器。

赋值和交换

c1 = c2   //删除容器c1的所有元素,然后将c2的元素复制给c1。c1和c2的类型(包括容器类型和元素类型)必须相同
c1.swap   //(c2)交换c1和c2的内容,比赋值操作速度快。
c.assign  //(b,e)将迭代器b和e标记的范围内所有的元素复制到c中。b和e必须不是指向c中元素的迭代器
c.assign  //(n,t)将容器c重新设置为存储n个值为t的元素

关联式容器是非线性的树结构,更准确的说是二叉树结构。各元素之间没有严格的物理上的顺序关系,也就是说元素在容器中并没有保存元素置入容器时的逻辑顺序。但是关联式容器提供了另一种根据元素特点排序的功能,这样迭代器就能根据元素的特点“顺序地”获取元素。元素是有序的集合,默认在插入的时候按升序排列。

关联容器包括:map(集合)、set(映射)、multimap(多重集合)、multiset(多重映射)。

map

map容器提供一个键值对(key/value)容器,map与multimap差别仅仅在于multiple允许一个键对应多个值。对于迭代器来说,可以修改实值,而不能修改key。Map会根据key自动排序。
map 是键-值对的集合。map 类型通常可理解为关联数组:可使用键作为下标来获取一个值,正如内置数组类型一样。而关联的本质在于元素的值与某个特定的键相关联,而并非通过元素在数组中的位置来获取。

初始化

#include <map>
map<k, v>m        //创建一个名为m的空map对象,其键和值的类型分别为k和v
map<k, v>m(m2)    //创建m2的副本m,m与m2必须有相同的键类型和值类型
map<k, v>m(b, e)  //创建map类型的对象m,存储迭代器b和e标记的范围内所有元素的副本,
                  //元素的类型必须能转换为pair<const k, v>。

在使用关联容器时,它的键不但有一个类型,而且还有一个相关的比较函数。所用的比较函数必须在键类型上定义严格弱排序(strict weak ordering):可理解为键类型数据上的“小于”关系,虽然实际上可以选择将比较函数设计得更复杂。对于键类型,唯一的约束就是必须支持 < 操作符,至于是否支持其他的关系或相等运算,则不作要求。

方法

添加元素有两种方法:1、先用下标操作符获取元素,然后给获取的元素赋值 2、使用insert成员函数实现
下标操作添加元素:如果该键已在容器中,则 map 的下标运算与 vector 的下标运算行为相同:返回该键所关联的值。只有在所查找的键不存在时,map 容器才为该键创建一个新的元素,并将它插入到此 map 对象中。此时,所关联的值采用值初始化:类类型的元素用默认构造函数初始化,而内置类型的元素初始化为 0。

m insert(e)    //e是一个用在m上的value_type 类型的值。如果键(e first不在m中,则插入一个值为e second 
               //的新元素;如果该键在m中已存在,则保持m不变。该函数返回一个pair类型对象,包含指向键为
               //e first的元素的map迭代器,以及一个 bool 类型的对象,表示是否插入了该元素
-------------------------------------------------------------------------------------------
m insert(beg,end)//beg和end是标记元素范围的迭代器,其中的元素必须为m value_type 类型的键-值对。对于
                 //该范围内的所有元素,如果它的键在m中不存在,则将该键及其关联的值插入到m。返回void类型
-------------------------------------------------------------------------------------------
m insert(iter,e)//e是一个用在m上的 value_type 类型的值。如果键(e first)不在m中,则创建新元素,并以
                //迭代器iter为起点搜索新元素存储的位置。返回一个迭代器,指向m中具有给定键的元素

遍历

map中使用下标存在一个很危险的副作用:如果该键不在 map 容器中,那么下标操作会插入一个具有该键的新元素。所以map 容器提供了两个操作:count 和 find,用于检查某个键是否存在而不会插入该键。

m count(k)   //返回 m 中 k 的出现次数
m find(k)    //如果m容器中存在按k索引的元素,则返回指向该元素的迭代器。如果不存在,则返回超出末端迭代器。

删除

m erase(k)      //删除m中键为k的元素。返回size_type类型的值,表示删除的元素个数
m erase(p)      //删除p所指向的元素。p必须指向m中确实存在的元素,而且不能等于m end()。返回void
m erase(b,e)    //从m中删除一段范围内的元素,该范围由迭代器对b和e标记。b和e必须标记m中的一段有效范围:即b和e都必须指向m中的元素或最后一个元素的下一个位置。而且,b和e要么相等(此时删除的范围为空),要么b所指向的元素必须出在e所指向的元素之前。返回 void 类型

set

set的含义是集合,它是一个有序的容器,里面的元素都是排序好的,支持插入,删除,查找等操作,就像一个集合一样。所有的操作的都是严格在logn时间之内完成,效率非常高。set和multiset的区别是:set插入的元素不能相同,但是multiset可以相同。Set默认自动排序。使用方法类似list。

begin()              //返回指向第一个元素的迭代器
clear()              //清除所有元素
count()              //返回某个值元素的个数
empty()              //如果集合为空,返回true
end()                //返回指向最后一个元素的迭代器
equal_range()        //返回集合中与给定值相等的上下限的两个迭代器
erase()              //删除集合中的元素
find()               //返回一个指向被查找到元素的迭代器
get_allocator()      //返回集合的分配器
insert()             //在集合中插入元素
lower_bound()        //返回指向大于(或等于)某值的第一个元素的迭代器
key_comp()           //返回一个用于元素间值比较的函数
max_size()           //返回集合能容纳的元素的最大限值
rbegin()             //返回指向集合中最后一个元素的反向迭代器
rend()               //返回指向集合中第一个元素的反向迭代器
size()               //集合中元素的数目
swap()               //交换两个集合变量
upper_bound()        //返回大于某个值元素的迭代器
value_comp()         //返回一个用于比较元素间的值的函数

举个栗子:

#include<set>
#include<iostream>
using namespace std;
int main()
{
    int i;
    int arr[5] = {0,1,2,3,4};
    set<int> iset(arr,arr+5);

    iset insert(5);
    cout<<"size:"<<iset size()<<endl;
    cout<<"3 count = "<<iset count(3)<<endl;
    iset erase(1);

    set<int>::iterator ite1 = iset begin();
    set<int>::iterator ite2 = iset end();
    for(;ite1!=ite2;ite1++)
    {
        cout<<*ite1;
    }
    cout<<endl;

    ite1 = iset find(3);
    if(ite1!=iset end())
        cout<<"3 found"<<endl;

    ite1 = iset find(1);
    if(ite1!=iset end())
        cout<<"1 not found"<<endl;
}

参考链接:
https://www.jianshu.com/p/fe909c102c08
https://www.jb51.net/article/115201.htm
https://blog.csdn.net/u014465639/article/details/70241850

posted @ 2020-05-11 06:40  多弗朗强哥  阅读(106)  评论(0编辑  收藏  举报