C++初阶——queue

一、什么是queue

        是一个容器适配器，专门设计用于在先进先出（FIFO，First In First Out）的上下文中操作。它是一个容器适配器，这意味着它不是一个完整的容器类，而是封装了一个特定的容器类（如list，deque等）作为其底层容器，并提供了一组特定的成员函数来访问其元素。

二、queue的定义及初始化

2.1queue的定义

#include<iostream>
#include<queue>
using namespace std;

int main()
{
    queue<内置类型>q1; //定义一个储存数据类型为int的queue容器q1 
    queue<自定义类型>q2; //定义一个储存数据类型为结构体类型的queue容器q2
    return 0;
}

2.2queue的初始化

#include <iostream>
#include <queue>
#include <vector>
using namespace std;

int main() {
    vector<int> v = { 1,2,4 };
    queue<int,vector<int>> q1(v);//用另一个容器进行初始化，第二个参数为用来初始化的容器类型
}

三、queue成员函数

3.1empty函数

bool empty() const;//函数原型

        返回队列是否为空：即其大小是否为零。这个成员函数实际上调用了底层容器对象的empty成员函数。

#include <queue>
#include <vector>
#include <iostream>
using namespace std;

int main() {
    vector<int> v = { 1,2,4 };
    queue<int, vector<int>> q1(v);
    queue<int> q2;
    cout << q1.empty() << endl;//s1不为空，所以返回值为0
    cout << q2.empty() << endl;//s2是一个空队列，返回值是1
}

3.2size函数 

size_type size() const;

        返回队列中的元素数量。这个成员函数实际上调用了底层容器对象的size成员函数。

#include <queue>
#include <vector>
#include <iostream>
using namespace std;

int main() {
    vector<int> v = { 1,2,4 };
    queue<int, vector<int>> q1(v);
    queue<int> q2;
    cout << q1.size() << endl;
    cout << q2.size() << endl;
}

3.3front函数和back函数

reference& front();
const_reference& front() const;

reference& back();
const_reference& back() const;

        front函数实际上是调用了底层容器对象的front成员函数。queue通常使用deque作为其底层容器，但也可以是其他容器，如list。无论使用哪种底层容器，front函数都会调用该容器的front方法来获取队列前端的元素。back函数同理

#include <queue>
#include <vector>
#include <iostream>
using namespace std;

int main() {
    vector<int> v = { 1,2,4 };
    queue<int, vector<int>> q1(v);
    cout << q1.front() << endl;
    cout << q1.back() << endl;
}

3.4push函数

void push (const value_type& val);
void push (value_type&& val);

        push函数用于在队列末尾插入一个新元，实际上是调用了底层容器对象的push_back成员函数。

#include <queue>
#include <vector>
#include <iostream>
using namespace std;

int main() {
    vector<int> v = { 1,2,4 };
    queue<int, vector<int>> q1(v);
    q1.push(10);
    cout << q1.front() << endl;
    cout << q1.back() << endl;
}

3.5pop函数

void pop();

        pop函数将移除队列前端的一个元素，从而将队列的大小减少一。如果队列为空，pop操作可能会抛出一个异常，具体取决于底层容器的实现。

        vector中没有pop_front成员函数，所以可能会需要程序员手动使用erase成员函数实现pop_front函数。

#include <queue>
#include <iostream>
using namespace std;

int main() {
    deque<int> d = { 1,2,4 };
    queue<int> q1(d);//queue底层默认是deque
    q1.pop();
    cout << q1.front() << endl;
    cout << q1.back() << endl;
}

3.6emplace函数 

template <class... Args> void emplace (Args&&... args);

        如果你想要就地构造一个新元素而不是复制或移动现有元素，你可以使用emplace方法。emplace方法允许你传递构造新元素所需的参数，这些参数会被转发到底层容器emplace_back 方法，后者会在容器的末尾就地构造新元素。 

#include <stack>
#include <queue>
#include <iostream>
using namespace std;

class A
{
public:
    int _a;
    int _b;
    A(int a = 0, int b = 0)
        :_a(a), _b(b)
    {}
};

int main() {
    queue<A> q;
    A a;
    q.push(a);
    q.emplace(10, 10);
    cout << q.front()._a << endl;
    q.pop();
    cout << q.front()._a << endl;
}

3.7swap函数

void swap (queue& x) noexcept(/*see below*/);

        这里的注释/*see below*/指的是noexcept后面的表达式，它用于指定该函数是否可能抛出异常。在queue的swap成员函数中，这个表达式依赖于底层容器的swap函数是否可能抛出异常。

        swap函数交换两个queue对象的内容。这是通过交换底层容器实现的，因为queue是一个容器适配器，它不直接存储元素，而是依赖于一个底层容器。

#include <vector>
#include <queue>
#include <iostream>
using namespace std;

int main() {
    vector<int> v1 = { 1,2,3 };
    vector<int> v2 = { 4,5,6 };
    queue<int, vector<int>> q1(v1);
    queue<int, vector<int>> q2(v2);
    cout << q1.front() << endl;
    cout << q2.front() << endl;
    q1.swap(q2);
    cout << q1.front() << endl;
    cout << q2.front() << endl;
}

        也可以用模板swap函数。

#include <vector>
#include <queue>
#include <iostream>
using namespace std;

int main() {
    vector<int> v1 = { 1,2,3 };
    vector<int> v2 = { 4,5,6 };
    queue<int, vector<int>> q1(v1);
    queue<int, vector<int>> q2(v2);
    cout << q1.front() << endl;
    cout << q2.front() << endl;
    swap(q1,q2);
    cout << q1.front() << endl;
    cout << q2.front() << endl;
}

四、运算符重载

        queue提供的比较运算符重载会将比较操作委托给其底层容器对象。这意味着，当你比较两个queue对象时，实际上是在比较它们底层容器中存储的元素序列。这点与stack容器适配器是一样的。