C++ STL queue队列使用

C++ queue

类模板：

template<
    class T,
    class Container = std::deque<T>
> class queue;

• 定义于头文件 <queue>
• std::queue 类是容器适配器，它给予程序员队列的功能——尤其是 FIFO （先进先出）数据结构。
• 类模板表现为底层容器的包装器——只提供特定的函数集合。 queue 在底层容器尾端推入元素，从首端弹出元素。

创建queue

构造函数

定义：

// 默认构造函数
queue() : queue(Container()) { }

// 以 cont 的内容复制构造底层容器 c 
explicit queue( const Container& cont );

// 以 std::move(cont) 移动构造底层容器 c 
explicit queue( Container&& cont );

// 复制构造函数
queue( const queue& other );

// 复制构造函数
queue( queue&& other );

用法：

    std::queue<int> c1;
 
    std::queue<int> c2(c1);
 
    std::deque<int> deq {3, 1, 4, 1, 5};
    std::queue<int> c3(deq);

operator=

• 赋值给容器适配器

定义：

queue& operator=( const queue& other );
queue& operator=( queue&& other );

用法：

queue<int> s1;
queue<int> s2;

s1 = s2;
s1 = std::move(s2);

元素访问

front

• 访问第一个元素

定义：

reference front();
const_reference front() const;

用法：

 	std::queue<int> s;
    s.push( 2 );
    s.push( 6 );
    s.push( 51 );

	std::cout << s.front() << std::endl;		// 2

back

• 访问最后一个元素

定义：

reference back();
const_reference back() const;

用法：

 	std::queue<int> s;
    s.push( 2 );
    s.push( 6 );
    s.push( 51 );

	std::cout << s.back() << std::endl;		// 51

容量

empty

• 检查底层的容器是否为空

bool empty() const;

• 返回值
  若底层容器为空则为 true ，否则为 false 。

size

• 返回容纳的元素数

size_type size() const;

修改器

push

• 向队列尾部插入元素

// 等效地调用 c.push_back(value)
void push( const value_type& value );

// 等效地调用 c.push_back(std::move(value))
void push( value_type&& value );

emplace

• 于顶原位构造元素

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

pop

• 删除首个元素
• 无返回值

void pop();

swap

• 交换内容

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

非成员函数

operator==、!=、<、<=、>、>=、<=>

按照字典顺序比较 queue 中的值

template< class T, class Container >
bool operator==( const std::queue<T,Container>& lhs, const std::queue<T,Container>& rhs );

template< class T, class Container >
bool operator!=( const std::queue<T,Container>& lhs, const std::queue<T,Container>& rhs );

template< class T, class Container >
bool operator<( const std::queue<T,Container>& lhs, const std::queue<T,Container>& rhs );

template< class T, class Container >
bool operator<=( const std::queue<T,Container>& lhs, const std::queue<T,Container>& rhs );

template< class T, class Container >
bool operator>( const std::queue<T,Container>& lhs, const std::queue<T,Container>& rhs );

template< class T, class Container >
bool operator>=( const std::queue<T,Container>& lhs, const std::queue<T,Container>& rhs );

template< class T, std::three_way_comparable Container >
std::compare_three_way_result_t<Container>
    operator<=>( const std::queue<T,Container>& lhs, const std::queue<T,Container>& rhs );

std::swap(std::queue)

• 特化 std::swap 算法

template< class T, class Container >
void swap( std::queue<T,Container>& lhs,
           std::queue<T,Container>& rhs );