stack的使用

 #include<stack>

方法

描述

stack.push(elem);

往栈顶添加元素。

stack.pop();

从栈顶移除第一个元素。

stack.top();

返回栈顶元素。

stack.empty();

判断堆栈是否为空，栈空返回true，栈非空返回false。

stack.size();

返回堆栈的大小，即堆栈中的元素数量。

queue的使用

#include<queue>

方法

描述

queue.push(elem)

把元素压入队列尾部。

queue.pop()

删除队首元素，但不返回该元素。

queue.front()

返回队首元素，但不删除。

queue.back()

返回队尾元素，但不删除。

queue.size()

返回队列中元素的个数。

queue.empty()

检查队列是否为空，如果为空返回true，否则返回false。

stack源码

容器适配器，它提供了特定的接口（ LIFO 栈操作），这些接口是通过封装另一个底层容器（如 deque, vector, 或 list）的功能实现的。这种设计允许 stack 继承底层容器的效率和存储能力，同时提供简化的接口以满足特定的数据结构需求。

指定底层容器的类型，deque 被用作默认容器。deque（双端队列）是一个高效的序列容器，允许在两端快速插入和删除。尽管 deque 是默认选择，但用户可以通过模板参数选择其他容器，如 vector 或 list，只要这些容器支持 back(), push_back(), 和 pop_back() 操作。

栈操作的实现：

empty()：直接调用底层容器的 empty() 方法来判断栈是否为空。

size()：调用底层容器的 size() 方法来获取栈中元素的数量。

top()：返回对底层容器最后一个元素的引用，即栈顶元素。这通过调用底层容器的 back() 方法实现。

push()：在底层容器的末尾添加一个元素，相当于将元素压入栈顶。这通过调用底层容器的 push_back() 方法实现。

pop()：移除底层容器的最后一个元素，相当于从栈顶移除一个元素。这通过调用底层容器的 pop_back() 方法实现。

// 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
};
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.
  • 29.
  • 30.
  • 31.
  • 32.
  • 33.
  • 34.
  • 35.
  • 36.
  • 37.
  • 38.
  • 39.
  • 40.
  • 41.
  • 42.
  • 43.
  • 44.
  • 45.
  • 46.
  • 47.
  • 48.
  • 49.
  • 50.
  • 51.
  • 52.
  • 53.
  • 54.
  • 55.
  • 56.
  • 57.
  • 58.
  • 59.
  • 60.
  • 61.
  • 62.
  • 63.

     通过封装底层容器，stack 类隐藏了容器操作的复杂性，为用户提供了一个简单且易于使用的 LIFO 数据结构。这种封装还提供了灵活性，因为底层容器可以很容易地被替换，而不影响 stack 类的公共接口。

queue源码

默认情况下，queue 使用 deque 作为其底层容器，因为 deque 支持高效的在两端插入和删除操作，符合队列的操作需求。然而，通过模板参数，用户可以指定其他类型的容器（如 list），只要这个容器支持 front(), back(), push_back(), 和 pop_front() 操作。

// 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
};
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.
  • 29.
  • 30.
  • 31.
  • 32.
  • 33.
  • 34.
  • 35.
  • 36.
  • 37.
  • 38.
  • 39.
  • 40.
  • 41.
  • 42.
  • 43.
  • 44.
  • 45.
  • 46.
  • 47.
  • 48.
  • 49.
  • 50.
  • 51.
  • 52.
  • 53.
  • 54.
  • 55.
  • 56.
  • 57.
  • 58.
  • 59.
  • 60.
  • 61.
  • 62.
  • 63.
  • 64.
  • 65.
  • 66.
  • 67.
  • 68.
  • 69.
  • 70.
  • 71.
  • 72.
  • 73.
  • 74.
  • 75.
  • 76.
  • 77.
  • 78.
  • 79.
  • 80.
  • 81.
  • 82.

入队（push）：在底层容器的尾部添加元素，对应于队列的尾部。

出队（pop）：从底层容器的头部移除元素，对应于队列的头部。

访问队首（front）和队尾（back）元素：通过直接访问底层容器的对应元素实现。

通过封装底层容器，queue 类隐藏了容器操作的复杂性，为用户提供了一个简单且易于使用的 FIFO 数据结构。这种封装还提供了灵活性，因为底层容器可以很容易地被替换，而不影响 queue 类的公共接口。queue 类模板的设计反映 C++ STL 容器和容器适配器的通用设计哲学，即通过组合和封装提供高效、灵活的数据结构实现。

参考

《STL源码剖析》