标签：
七种基本容器：vector、deque、list、set、multiset、map、multimap
一、容器适配器
stack
queue
priority_queue
stack、queue、priority_queue 都不支持任一种迭代器，它们都是容器适配器类型，stack是用vector/deque/list对象创建了一个先进后出容器；queue是用deque或list对象创建了一个先进先出容器；priority_queue是用vector/deque创建了一个排序队列，内部用二叉堆实现。
二、stack
1、示例
#include <iostream>
#include <vector>
#include <list>
#include <stack>
using namespace std;
int main(void)
{
stack<int, list<int> > s; //set则出错
for (int i = 0; i < 5; i++)
{
s.push(i);
}
//for (size_t i=0; i<s.size(); i++)
//{
// cout<<s.top()<<' '; Error:size()一直在变化
// s.pop();
//}
while (!s.empty())
{
cout << s.top() << ' ';
s.pop();
}
cout << endl;
return 0;
}
2、源码分析
// TEMPLATE CLASS stack
template < class _Ty,
class _Container = deque<_Ty> >
class stack
{
// LIFO queue implemented with a container
public:
typedef _Container container_type;
typedef typename _Container::value_type value_type;
typedef typename _Container::size_type size_type;
typedef typename _Container::reference reference;
typedef typename _Container::const_reference const_reference;
stack()
: c()
{
// construct with empty container
}
explicit stack(const _Container &_Cont)
: c(_Cont)
{
// construct by copying specified container
}
bool empty() const
{
// test if stack is empty
return (c.empty());
}
size_type size() const
{
// test length of stack
return (c.size());
}
reference top()
{
// return last element of mutable stack
return (c.back());
}
const_reference top() const
{
// return last element of nonmutable stack
return (c.back());
}
void push(const value_type &_Val)
{
// insert element at end
c.push_back(_Val);
}
void pop()
{
// erase last element
c.pop_back();
}
const _Container &_Get_container() const
{
// get reference to container
return (c);
}
protected:
_Container c; // the underlying container
};
三、queue
1、示例
#include <iostream>
#include <vector>
#include <list>
#include <stack>
#include <queue>
using namespace std;
int main(void)
{
//int a[] = {1, 2, 3, 4, 5};
//vector<int> v(a, a+5);
//queue<int> q(a, a+5) //出错，不能这么初始化
queue<int, list<int> > q; //vector出错，必须要支持pop的函数的才行
for (int i = 0; i < 5; i++)
{
q.push(i);
}
while (!q.empty())
{
cout << q.front() << ' ';
q.pop();
}
cout << endl;
return 0;
}
2、源码分析
// TEMPLATE CLASS queue
template < class _Ty,
class _Container = deque<_Ty> >
class queue
{
// FIFO queue implemented with a container
public:
typedef _Container container_type;
typedef typename _Container::value_type value_type;
typedef typename _Container::size_type size_type;
typedef typename _Container::reference reference;
typedef typename _Container::const_reference const_reference;
queue()
: c()
{
// construct with empty container
}
explicit queue(const _Container &_Cont)
: c(_Cont)
{
// construct by copying specified container
}
bool empty() const
{
// test if queue is empty
return (c.empty());
}
size_type size() const
{
// return length of queue
return (c.size());
}
reference front()
{
// return first element of mutable queue
return (c.front());
}
const_reference front() const
{
// return first element of nonmutable queue
return (c.front());
}
reference back()
{
// return last element of mutable queue
return (c.back());
}
const_reference back() const
{
// return last element of nonmutable queue
return (c.back());
}
void push(const value_type &_Val)
{
// insert element at beginning
c.push_back(_Val);
}
void pop()
{
// erase element at end
c.pop_front();
}
const _Container &_Get_container() const
{
// get reference to container
return (c);
}
protected:
_Container c; // the underlying container
};
四、priority_queue
1、示例
#include <iostream>
#include <functional>
#include <vector>
#include <list>
#include <stack>
#include <queue>
using namespace std;
int main(void)
{
int a[] = {5, 1, 2, 4, 3};
priority_queue<int, vector<int>, greater<int> > q(a, a + 5); //默认从大到小，必须有三个参数才能调用greater<int>
//priority_queue<int, vector<int>, less<int> > q(a, a + 5);
while (!q.empty())
{
cout << q.top() << ' ';
q.pop();
}
cout << endl;
return 0;
}
2、源码分析
// TEMPLATE CLASS priority_queue
template < class _Ty,
class _Container = vector<_Ty>,
class _Pr = less<typename _Container::value_type> >
class priority_queue
{
// priority queue implemented with a _Container
public:
typedef _Container container_type;
typedef typename _Container::value_type value_type;
typedef typename _Container::size_type size_type;
typedef typename _Container::reference reference;
typedef typename _Container::const_reference const_reference;
priority_queue()
: c(), comp()
{
// construct with empty container, default comparator
}
explicit priority_queue(const _Pr &_Pred)
: c(), comp(_Pred)
{
// construct with empty container, specified comparator
}
priority_queue(const _Pr &_Pred,const _Container &_Cont)
: c(_Cont), comp(_Pred)
{
// construct by copying specified container, comparator
make_heap(c.begin(), c.end(), comp);
}
template<class_Iter>
priority_queue(_Iter _First, _Iter _Last)
: c(_First, _Last), comp()
{
// construct by copying [_First, _Last), default comparator
make_heap(c.begin(), c.end(), comp);
}
template<class_Iter>
priority_queue(_Iter _First, _Iter _Last, const _Pr &_Pred)
: c(_First, _Last), comp(_Pred)
{
// construct by copying [_First, _Last), specified comparator
make_heap(c.begin(), c.end(), comp);
}
template<class_Iter>
priority_queue(_Iter _First, _Iter _Last, const _Pr &_Pred,
const _Container &_Cont)
: c(_Cont), comp(_Pred)
{
// construct by copying [_First, _Last), container, and comparator
c.insert(c.end(), _First, _Last);
make_heap(c.begin(), c.end(), comp);
}
bool empty() const
{
// test if queue is empty
return (c.empty());
}
size_type size() const
{
// return length of queue
return (c.size());
}
const_reference top() const
{
// return highest-priority element
return (c.front());
}
reference top()
{
// return mutable highest-priority element (retained)
return (c.front());
}
void push(const value_type &_Pred)
{
// insert value in priority order
c.push_back(_Pred);
push_heap(c.begin(), c.end(), comp);
}
void pop()
{
// erase highest-priority element
pop_heap(c.begin(), c.end(), comp);
c.pop_back();
}
protected:
_Container c; // the underlying container
_Pr comp; // the comparator functor
};
priority_queue 的实现稍微复杂一点，可以传递3个参数，而且有两个成员，comp 即自定义比较逻辑，默认是less<value_type>，在构造函数中调用make_heap函数构造二叉堆，comp 主要是用于构造二叉堆时的判别，如果是less 则构造大堆，如果传递greater 则构造小堆.
注意，priority_queue 不能用list 实现，因为list 只支持双向迭代器，而不支持随机迭代器。
下面举个例子说明make_heap 函数的用法(构造一个二叉堆)：
#include <iostream>
#include <functional>
#include <vector>
#include <list>
#include <stack>
#include <queue>
#include <iterator>
using namespace std;
int main(void)
{
int a[] = {5, 1, 2, 4, 3};
make_heap(a, a + 5, less<int>());
copy(a, a + 5, ostream_iterator<int>(cout, " "));
cout << endl;
sort(a, a + 5);
//sort_heap(a, a+5, less<int>()); //对应于make_heap的less
copy(a, a + 5, ostream_iterator<int>(cout, " "));
cout << endl;
return 0;
}
5 4 2 1 3
1 2 3 4 5
make_heap() 将容器的元素构造成二叉堆，传递的是less，即构造的是大堆，把大堆层序遍历的结果存入数组，再调用sort() 进行排序，内部调用的实际算法不一定，可以是堆排序、插入排序、选择排序等等，跟踪进去发现调用的是插入排序；当然也可以直接指定使用堆排序 sort_heap（调用者必须已经是堆了，也就是前面已经先调用了make_heap，而且大小堆类型得匹配），与make_heap 一样，第三个参数传递的都是函数对象的用法。sort 和 sort_heap 默认都是从小到大排序，除非重载的版本传递了第三个参数，如下，第三个参数可以是函数指针，也可以是函数对象：
// order heap by repeatedly popping, using operator<
template<class _RanIt> inline
void sort_heap(_RanIt _First, _RanIt _Last);
// order heap by repeatedly popping, using _Pred
template < class _RanIt,
class _Pr > inline
void sort_heap(_RanIt _First, _RanIt _Last, _Pr _Pred);
参考：
C++ primer 第四版
Effective C++ 3rd
C++编程规范
C++ Primer 学习笔记_55_STL剖析（十）：容器适配器（stack、 queue 、priority_queue）源码浅析与使用示例
标签：
原文地址：http://blog.csdn.net/keyyuanxin/article/details/50696898
