STL总结二

stack容器

• 简介

  stack是堆栈容器，是一种“先进后出”的容器。
  stack是简单地装饰deque容器而成为另外的一种容器。
  

栈不能遍历，不支持随机随机存取，只能通过top从栈顶获取和删除元素

• stack的push()与pop()方法

  stack.push(elem);   //往栈头添加元素
  
  stack.pop();   //从栈头移除第一个元素
  

• stack对象的拷贝构造与赋值

  stack(const stack &stk);  //拷贝构造函数
  
  stack& operator=(const stack &stk);       //重载等号操作符
  

• stack的数据存取

  stack.top();   //返回最后一个压入栈元素
  

stack的大小

stack.empty();   //判断堆栈是否为空

stack.size();              //返回堆栈的大小

Queue容器

• Queue简介

  queue是队列容器，是一种“先进先出”的容器。
  
  queue是简单地装饰deque容器而成为另外的一种容器。
  

  队列不能遍历，不提供迭代器，不支持随机访问

• queue的push()与pop()方法

  queue.push(elem);   //往队尾添加元素
  
  queue.pop();   //从队头移除第一个元素
  

• queue对象的拷贝构造与赋值

  queue(const queue &que);  //拷贝构造函数
  
  queue& operator=(const queue &que); //重载等号操作符
  

• queue的数据存取

  queue.back();   //返回最后一个元素
  
  queue.front();   //返回第一个元素
  

• queue的大小

  queue.empty();   //判断队列是否为空  queue.size();      
      //返回队列的大小
  

• Set和multiset容器

set是一个集合容器，其中所包含的元素是唯一的，集合中的元素按一定的顺序排列。元素插入过程是按排序规则插入，所以不能指定插入位置。

set采用红黑树变体的数据结构实现，红黑树属于平衡二叉树。在插入操作和删除操作上比vector快。

set不可以直接存取元素。（不可以使用at.(pos)与[]操作符）。

multiset与set的区别：set支持唯一键值，每个元素值只能出现一次；而multiset中同一值可以出现多次。

不可以直接修改set或multiset容器中的元素值，因为该类容器是自动排序的。如果希望修改一个元素值，必须先删除原有的元素，再插入新的元素

• set/multiset对象的默认构造

set< int > setInt; //一个存放int的set容器。

set< float > setFloat; //一个存放float的set容器。

set< string> setString; //一个存放string的set容器。

multiset< int> mulsetInt; //一个存放int的multi set容器。

multi set< float> multisetFloat; //一个存放float的multi set容器。

multi set< string>multisetString; //一个存放string的multi set容器。

• set的插入与迭代器

set.insert(elem); //在容器中插入元素。

set.begin(); //返回容器中第一个数据的迭代器。

set.end(); //返回容器中最后一个数据之后的迭代器。

set.rbegin(); //返回容器中倒数第一个元素的迭代器。

set.rend(); //返回容器中倒数最后一个元素的后面的迭代器。

for(set< int>::iterator it=setInt.begin(); it!=setInt.end(); ++it)
{
int iItem = *it;
cout << iItem; //或直接使用cout << *it
}

Set集合的元素排序

set<int,less< int> >
setIntA; //该容器是按升序方式排列元素。

set<int,greater< int>> setIntB; //该容器是按降序方式排列元素。

set< int> 相当于 set<int,less< int>>。

less< int>与greater< int>中的int可以改成其它类型，该类型主要要跟set容纳的数据类型一致。

疑问1：less<>与greater<>是什么？

疑问2：如果set<>不包含int类型，而是包含自定义类型，set容器如何排序？

要解决如上两个问题，需要了解容器的函数对象，也叫伪函数，英文名叫functor。

• 函数对象functor的用法

尽管函数指针被广泛用于实现函数回调，但C++还提供了一个重要的实现回调函数的方法，那就是函数对象。

functor，翻译成函数对象，伪函数，算符，是重载了“()”操作符的普通类对象。从语法上讲，它与普通函数行为类似。

greater<>与less<>就是函数对象。

下面举出greater的简易实现原理。

下面举出greater的简易实现原理。

struct greater
{
bool operator()(const int& iLeft, const int& iRight)
{
return (iLeft>iRight); //如果是实现less的话，这边是写return (iLeft<iRight);
}
}
容器就是调用函数对象的operator()方法去比较两个值的大小。

• set对象的拷贝构造与赋值

set(const set &st); //拷贝构造函数

set& operator=(const set &st); //重载等号操作符

set.swap(st); //交换两个集合容器

• set的大小

set.size(); //返回容器中元素的数目

set.empty();//判断容器是否为空

• set的删除

set.clear(); //清除所有元素

set.erase(pos); //删除pos迭代器所指的元素，返回下一个元素的迭代器。

set.erase(beg,end); //删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。

set.erase(elem); //删除容器中值为elem的元素。

• set的查找

set.find(elem); //查找elem元素，返回指向elem元素的迭代器。

set.count(elem); //返回容器中值为elem的元素个数。对set来说，要么是0，要么是1。对multiset来说，值可能大于1。

set.lower_bound(elem); //返回第一个>=elem元素的迭代器。

set.upper_bound(elem); // 返回第一个>elem元素的迭代器。

set.equal_range(elem); //返回容器中与elem相等的上下限的两个迭代器。上限是闭区间，下限是开区间，如[beg,end)。

以上函数返回两个迭代器，而这两个迭代器被封装在pair中。

• 以下讲解pair的含义与使用方法。

  set< int>::iterator itA =setInt.find(5);
  int iA = *itA;             //iA == 5
  int iCount = setInt.count(5);   //iCount == 1
  set< int>::iterator
  itB = setInt.lower_bound(5);
  set< int>::iterator itC = setInt.upper_bound(5)
  int iB = *itB;     //iB == 5
  int iC = *itC; //iC == 7
  

pair<set< int>::iterator, set< int>::iterator > pairIt =setInt.equal_range(5); //pair是什么？

• pair的使用

pair译为对组，可以将两个值视为一个单元。

pair<T1,T2>存放的两个值的类型，可以不一样，如T1为int，T2为float。T1,T2也可以是自定义类型。

pair.first是pair里面的第一个值，是T1类型。
pair.second是pair里面的第二个值，是T2类型。

set< int> setInt;
... //往setInt容器插入元素1,3,5,7,9
pair< set< int>::iterator ,
set< int>::iterator > pairIt = setInt.equal_range(5);//大于等于5
set< int>::iterator itBeg = pairIt.first;
set< int>::iterator  itEnd = pairIt.second;//此时 *itBeg==5  而  *itEnd == 7

• Map和multimap容器

map/multimap的简介

map是标准的关联式容器，一个map是一个键值对序列，即(key,value)对。它提供基于key的快速检索能力。

map中key值是唯一的。集合中的元素按一定的顺序排列。元素插入过程是按排序规则插入，所以不能指定插入位置。

map的具体实现采用红黑树变体的平衡二叉树的数据结构。在插入操作和删除操作上比vector快。

map可以直接存取key所对应的value，支持[]操作符，如map[key]=value。

multimap与map的区别：map支持唯一键值，每个键只能出现一次；而multimap中相同键可以出现多次。multimap不支持[]操作符。

• map/multimap对象的默认构造

map/multimap采用模板类实现，对象的默认构造形式：

map<T1,T2> mapTT; 

multimap<T1,T2>  multimapTT; 

如：

map<int, char> mapA;

map<string,float> mapB;

//其中T1,T2还可以用各种指针类型或自定义类型

• map的插入与迭代器

map.insert(…); //往容器插入元素，返回pair<iterator,bool>

在map中插入元素的三种方式：

假设 map<int, string>mapStu;

一、通过pair的方式插入对象

mapStu.insert( pair<int,string>(3,“小张”) );

二、通过pair的方式插入对象

mapStu.inset(make_pair(-1,“校长-1”));

三、通过value_type的方式插入对象

mapStu.insert( map<int,string>::value_type(1,“小李”) );

四、通过数组的方式插入值

mapStu[3] = “小刘";

mapStu[5] = “小王"；

前三种方法，采用的是insert()方法，该方法返回值为pair<iterator,bool>

第四种方法非常直观，但存在一个性能的问题。插入3时，先在mapStu中查找主键为3的项，若没发现，则将一个键为3，值为初始化值的对组插入到mapStu中，然后再将值修改成“小刘”。若发现已存在3这个键，则修改这个键对应的value。

string strName = mapStu[2]; //取操作或插入操作

只有当mapStu存在2这个键时才是正确的取操作，否则会自动插入一个实例，键为2，值为初始化值。

• map对象的拷贝构造与赋值

map(const map &mp); //拷贝构造函数

map& operator=(const map &mp); //重载等号操作符

map.swap(mp); //交换两个集合容器

例如:

map<int,
string> mapA;
mapA.insert(pair<int,string>(3,"小张"));       
map<int ,string> mapB(mapA);                        //拷贝构造                 
map<int,
string> mapC;
mapC= mapA;                                                             //赋值
mapC[3]= "老张";
mapC.swap(mapA);                  //交换

• map的大小

  map.size(); //返回容器中元素的数目

  map.empty();//判断容器是否为空

• map的删除

  map.clear();                //删除所有元素
  
  map.erase(pos); //删除pos迭代器所指的元素，返回下一个元素的迭代器。
  
  map.erase(beg,end);     //删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。
  
  map.erase(keyElem);     //删除容器中key为keyElem的对组。
  

• map的查找

  map.find(key);   查找键key是否存在，若存在，返回该键的元素的迭代器；若不存在，返回map.end();
  
  map.count(keyElem);   //返回容器中key为keyElem的对组个数。对map来说，要么是0，要么是1。对multimap来说，值可能大于1。