C++ STL queue队列使用

C++ queue

queue

• C++ queue
• • 创建queue
  • • 构造函数
    • operator=
  • 元素访问
  • • front
    • back
  • 容量
  • • empty
    • size
  • 修改器
  • • push
    • emplace
    • pop
    • swap
  • 非成员函数
  • • operator==、!=、<、<=、>、>=、<=>
    • std::swap(std::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

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

• 返回值

  若底层容器为空则为 true ，否则为 false 。

size

• 返回容纳的元素数

修改器

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

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

swap

• 交换内容

非成员函数

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 );