1 容器适配器
适配器是一种设计模式(设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结),该种模式是将一个类的接口转换成客户希望的另外一个接口。
1.1 STL标准库中stack和queue的底层结构
虽然stack和queue中也可以存放元素,但在STL中并没有将其划分在容器的行列,而是将其称为容器适配器,这是因为stack和queue只是对其他容器的接口进行了包装,STL中stack和queue默认使用deque,比如官方的stack类:template <class T, class Container = deque<T> > class stack;
1.2 deque的简单介绍
1.2.1 deque的原理介绍
deque(双端队列):是一种双开口的"连续"空间的数据结构,双开口的含义是:可以在头尾两端进行插入和删除操作,且时间复杂度为O(1),与vector比较,头插效率高,不需要搬移元素;与list比较,空间利用率比较高。
deque并不是真正连续的空间,而是由一段段连续的小空间拼接而成的,实际deque类似于一个动态的二维数组,其底层结构如下图所示:
双端队列底层是一段假象的连续空间,实际是分段连续的,为了维护其"整体连续"以及随机访问的假象,落在了deque的迭代器身上,因此deque的迭代器设计就比较复杂,如下图所示:
deque借助其迭代器维护其假想的连续结构的方式: 
cpp
// 这里说明一下,deque的主要成员变量有四个
iterator start_; //指向map的头部
iterator finish_; //指向map的尾部
map_Pointer map_; //指向map(map为一段连续空间),其内部元素为指针,每个指针指向一个缓存区
size_type map_size_; //map内部指针的个数
1.2.2 deque的缺陷
与vector比较,deque的优势是:头部插入和删除时,不需要搬移元素,效率特别高,而且在扩容时,也不需要搬移大量的元素,因此其效率是比vector高的;与list比较,其底层是连续空间,空间利用率比较高,不需要存储额外字段。但是,deque有一个致命缺陷:不适合遍历,因为在遍历时,deque的迭代器要频繁的去检测其是否移动到某段小空间的边界,导致效率低下,而序列式场景中,可能需要经常遍历,因此在实际中,需要线性结构时,大多数情况下优先考虑vector和list,deque的应用并不多,而目前能看到的一个应用就是,STL用其作为stack和queue的底层数据结构。
1.2.3 为什么选择deque作为stack和queue的底层默认容器
stack是一种后进先出的特殊线性数据结构,因此只要具有push_back()和pop_back()操作的线性结构,都可以作为stack的底层容器,比如vector和list都可以;queue是先进先出的特殊线性数据结构,只要具有push_back()和pop_front()操作的线性结构,都可以作为queue的底层容器,比如list。但是STL中对stack和queue默认选择deque作为其底层容器,主要是因为:
stack和queue不需要遍历(因此stack和queue没有迭代器),只需要在固定的一端或者两端进行操作。- 在
stack中元素增长时,deque比vector的效率高(扩容时不需要搬移大量数据);queue中的元素增长时,deque不仅效率高,而且内存使用率高。
选择deque作为默认容器,结合了deque的优点,而完美的避开了其缺陷。
2 stack的介绍和使用
2.1 stack的使用
- 构造函数

- 其他接口

2.2 stack的模拟实现
cpp
namespace Sashtok
{
// Container适配转换出stack
template<class T, class Container = std::deque<T>>
class stack
{
public:
void push(const T& x)
{
_con.push_back(x);
}
void pop()
{
// 类模板实例化时,按需实例化,使用哪些成员函数就实例化哪些,不会全实例化
//_con.pop();// 比如,这里写成这样,deque没有pop()接口
// 如果不调用stack的pop(),编译器不会报错,调用了,才会报错
_con.pop_back();
}
const T& top() const
{
return _con.back();
}
size_t size() const
{
return _con.size();
}
bool empty() const
{
return _con.empty();
}
private:
Container _con;
};
}
3 queue的介绍和使用
3.1 queue的使用
- 构造函数

- 其他接口

3.2 queue的模拟实现
cpp
namespace Sashtok
{
template<class T, class Container = std::deque<T>>
class queue
{
public:
void push(const T& x)
{
_con.push_back(x);
}
void pop()
{
_con.pop_front();
}
const T& front() const
{
return _con.front();
}
const T& back() const
{
return _con.back();
}
size_t size() const
{
return _con.size();
}
bool empty() const
{
return _con.empty();
}
private:
Container _con;
};
}
4 priority_queue的介绍和使用
4.1 priority_queue的使用
优先级队列默认使用vector作为其底层存储数据的容器,在vector上又使用了堆算法将vector中 元素构造成堆的结构,因此priority_queue就是堆,所有需要用到堆的位置,都可以考虑使用priority_queue。注意:默认情况下priority_queue是大堆。
- 构造函数

- 其他接口

注意:
-
默认情况下,
priority_queue是大堆。cpp#include <queue> #include <functional> // greater算法的头文件, 有时候会被间接包含 // greater是仿函数,下面会讲到 int main() { // 默认情况下,创建的是大堆,其底层按照小于号比较 std::vector<int> v{3,2,7,6,0,4,1,9,8,5}; std::priority_queue<int> q1; for (auto& e: v) { q1.push(e); } std::cout << q1.top() << std::endl; // 如果要创建小堆,将第三个模板参数换成greater比较方式 std::priority_queue<int, std::vector<int>, std::greater<int>> q2(v.begin(), v.end()); std::cout << q2.top() << std::endl; return 0; } -
如果在
priority_queue中放自定义类型的数据,用户需要在自定义类型中提供>或者<的重载。cppclass A { friend std::ostream& operator<<(std::ostream& os, const A& a); public: A(int x = 0) : _a(x) {} bool operator<(const A& other) const { return _a < other._a; } bool operator>(const A& other) const { return _a > other._a; } private: int _a; }; std::ostream& operator<<(std::ostream& os, const A& a) { os << a._a; return os; } int main() { // 大堆,需要用户在自定义类型中提供<的重载 std::priority_queue<A> pq1;// A类自己重载了<、>运算符 pq1.push(A(1)); pq1.push(A(2)); pq1.push(A(3)); pq1.push(A(4)); // 如果要创建小堆,需要用户提供>的重载 std::priority_queue<A, std::vector<A>, std::greater<A>> pq2; pq1.push(A(1)); pq1.push(A(2)); pq1.push(A(3)); pq1.push(A(4)); return 0; }
4.2 仿函数
仿函数:本质是一个类,这个类重载了()操作符,他的对象可以像函数一样访问,仿函数的对象叫做函数对象。
cpp
// 自己实现的less和greater仿函数
// 仿函数没有成员变量,但是其大小是1字节
template<class T>
class less
{
public:
bool operator()(const T& x, const T& y) const
{
return x < y;
}
};
template<class T>
class greater
{
public:
bool operator()(const T& x, const T& y) const
{
return x > y;
}
};
需要自己写仿函数的情况:
- 类类型不支持比较大小
- 支持比较大小,但是比较的逻辑不是我们想要的
cpp
class A
{
public:
A(int x = 0)
: _a(x)
{}
bool operator<(const A& other) const
{
return _a < other._a;
}
bool operator>(const A& other) const
{
return _a > other._a;
}
private:
int _a;
};
// 仿函数
class Aless
{
public:
bool operator()(A* p1, A* p2)
{
return *p1 < *p2;
}
};
int main()
{
std::priority_queue<A> pq1;// A类自己重载了<、>运算符
pq1.push(A(1));
pq1.push(A(2));
pq1.push(A(3));
pq1.push(A(4));
//std::priority_queue<A*> pq2;// 这里是按地址比较的,但是new的地址是随机的,所以结果也是随机的
// 也就是支持比较大小,但是比较的逻辑不是我们想要的
std::priority_queue<A*, std::vector<A*>, Aless> pq2;// 这里用自己写的Aless就可以解决
pq2.push(new A(1));
pq2.push(new A(2));
pq2.push(new A(3));
pq2.push(new A(4));
std::cout << *pq2.top() << std::endl;
pq2.pop();
std::cout << *pq2.top() << std::endl;
pq2.pop();
std::cout << *pq2.top() << std::endl;
pq2.pop();
std::cout << *pq2.top() << std::endl;
pq2.pop();
return 0;
}
4.3 priority_queue的模拟实现
cpp
namespace Sashtok
{
// 这里用库里的less或自己实现的less都可以
template<class T, class Container = std::vector<T>, class Compare = less<T>>
class priority_queue
{
public:
void adjustUp(int child)
{
Compare com;
int parent = (child - 1) / 2;
while (parent >= 0 && com(_con[parent], _con[child]))
{
std::swap(_con[parent], _con[child]);
child = parent;
parent = (child - 1) / 2;
}
}
void push(const T& x)
{
_con.push_back(x);
adjustUp(_con.size() - 1);
}
void adjustDown(int parent)
{
Compare com;
int child = parent * 2 + 1;
if (child + 1 < _con.size() && com(_con[child], _con[child + 1]))
{
child++;
}
while (child < _con.size() && com(_con[parent], _con[child]))
{
std::swap(_con[parent], _con[child]);
parent = child;
child = parent * 2 + 1;
if (child + 1 < _con.size() && com(_con[child], _con[child + 1]))
{
child++;
}
}
}
void pop()
{
std::swap(_con[0], _con[_con.size() - 1]);
_con.pop_back();
adjustDown(0);
}
const T& top() const
{
return _con[0];
}
size_t size() const
{
return _con.size();
}
bool empty() const
{
return _con.empty();
}
private:
Container _con;
};
}
5 总结
本文系统梳理了STL中的三大容器适配器stack、queue和priority_queue。
所谓适配器,本质上是一种设计模式,通过组合而非继承,将底层容器(如deque、vector)的接口进行封装,从而提供特定的数据结构行为。在底层容器的选择上,stack和queue默认选用deque,完美避开了vector扩容代价大和list缓存命中率低的问题,实现了头尾操作的高效性。
此外,priority_queue的实现让我对仿函数(Functor)有了更深刻的认识。通过自定义仿函数,我们能灵活控制堆的排序规则(如建大堆或小堆)。