适配器

介绍

在C++的标准模板库（STL）中，有几种适配器，它们是一些容器或函数对象的包装，提供了不同的接口和功能，用于适应特定的需求

分类 

STL中的适配器可以分为两类：容器适配器和迭代器适配器

容器适配器

容器适配器用来包装不同种类的容器，并提供统一的接口(其实就是将我们常见的容器包装一下,用来实现其他容器的功能)

常见的容器适配器有：

• stack（栈）： 用于实现后进先出（LIFO）的数据结构，基于另一个容器（默认是deque）来实现
• queue（队列）： 用于实现先进先出（FIFO）的数据结构，也是基于另一个容器（默认是deque）来实现
• priority_queue（优先队列）： 用于实现优先级排序的数据结构，基于另一个容器（默认是vector）来实现

迭代器适配器

迭代器适配器是用来调整迭代器的功能，以满足不同的需求

(这个我目前还不清楚,看了下示例代码,感觉好麻烦的样子) 

deque

介绍

双端队列，全称为 "double-ended queue" , 是C++标准库中提供的一种容器，它是一种支持在两端进行高效插入和删除操作的数据结构

特点 

既可以支持像list一样的头插头删尾插尾删,又支持vector的[ ]操作,以及它支持的迭代器是随机迭代器

内部采用分块存储,用一个指针数组指向多个buf

• 尾插就直接往后填,头插从后往前填
• 但对于中间位置的数据就很难去处理,因此deque适合需要频繁头插尾插头删尾删的情况
• 也就是栈/队列,虽然他俩出数据方式不同,但都只会访问头尾位置的数据

介绍

stack（栈）： 用于实现后进先出（LIFO）的数据结构，基于另一个容器（默认是deque）来实现

queue（队列）： 用于实现先进先出（FIFO）的数据结构，也是基于另一个容器（默认是deque）来实现

模拟实现

注意点

适配器使用的容器的传参(默认deque)

构造/析构函数不需要自己实现,成员是自定义类型,会调用它自己的构造/析构的

代码

stack

#include <iostream>
#include <vector>
#include <list>
#include <deque>
using namespace std;


namespace bit
{
    template <class T, class Con = deque<T>> // con是适配器(也就是容器适配器,其他容器经过包装 -> stack)
    class mystack
    {
    public:
        mystack() {}
        void push(const T &x)
        {
            _c.push_back(x);
        }
        void pop()
        {
            _c.pop_back();
        }
        T &top()
        {
            return _c.back();
        }
        const T &top() const
        {
            return _c.front();
        }
        size_t size() const
        {
            return _c.size();
        }
        bool empty() const
        {
            return _c.empty();
        }


    private:
        Con _c;
    };
};

queue

namespace bit
{
    template <class T, class Con = deque<T>>
    class myqueue
    {
    public:
        myqueue() {}
        void push(const T &x)
        {
            _c.push_back(x);
        }
        void pop()
        {
            _c.pop_front();
        }
        T &back()
        {
            return _c.back();
        }
        const T &back() const
        {
            return _c.back();
        }
        T &front()
        {
            return _c.front();
        }
        const T &front() const
        {
            return _c.front();
        }
        size_t size() const
        {
            return _c.size();
        }
        bool empty() const
        {
            return _c.empty();
        }


    private:
        Con _c;
    };
}