cpp基础知识(10)

0 阅读7分钟

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类似于一个动态的二维数组,其底层结构如下图所示: image.png 双端队列底层是一段假象的连续空间,实际是分段连续的,为了维护其“整体连续”以及随机访问的假象,落在了deque的迭代器身上,因此deque的迭代器设计就比较复杂,如下图所示: image.png deque借助其迭代器维护其假想的连续结构的方式: image.png

// 这里说明一下,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作为其底层容器,主要是因为:

  1. stack和queue不需要遍历(因此stack和queue没有迭代器),只需要在固定的一端或者两端进行操作。
  2. 在stack中元素增长时,deque比vector的效率高(扩容时不需要搬移大量数据);queue中的元素增长时,deque不仅效率高,而且内存使用率高。

选择deque作为默认容器,结合了deque的优点,而完美的避开了其缺陷。

2 stack的介绍和使用

stack的官方文档

2.1 stack的使用

  • 构造函数 image.png
  • 其他接口 image.png

2.2 stack的模拟实现

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的介绍和使用

queue的官方文档

3.1 queue的使用

  • 构造函数 image.png
  • 其他接口 image.png

3.2 queue的模拟实现

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的介绍和使用

priority_queue的官方文档

4.1 priority_queue的使用

优先级队列默认使用vector作为其底层存储数据的容器,在vector上又使用了堆算法将vector中 元素构造成堆的结构,因此priority_queue就是堆,所有需要用到堆的位置,都可以考虑使用priority_queue。注意:默认情况下priority_queue是大堆。

  • 构造函数 image.png
  • 其他接口 image.png

注意:

  1. 默认情况下,priority_queue是大堆。
    #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;
    }
    
  2. 如果在priority_queue中放自定义类型的数据,用户需要在自定义类型中提供>或者<的重载。
    class 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 仿函数

仿函数:本质是一个类,这个类重载了()操作符,他的对象可以像函数一样访问,仿函数的对象叫做函数对象。

// 自己实现的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;
    }
};

需要自己写仿函数的情况:

  1. 类类型不支持比较大小
  2. 支持比较大小,但是比较的逻辑不是我们想要的
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的模拟实现

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)有了更深刻的认识。通过自定义仿函数,我们能灵活控制堆的排序规则(如建大堆或小堆)。