From cppreference.com
This header is part of the
library.
Includes
(C++20)
support
(C++11)
class template
Classes
adapts a container to provide queue (FIFO data structure)
(class template)
adapts a container to provide priority queue
(class template)
std::uses_allocator<std::queue>
(C++11)
specializes the
type trait
(class template specialization)
std::uses_allocator<std::priority_queue>
(C++11)
specializes the
type trait
(class template specialization)
Functions
operator==operator!=operator<operator<=operator>operator>=operator<=>
(C++20)
lexicographically compares the values of two queues
(function template)
(C++11)
specializes the
algorithm
(function template)
std::swap(std::priority_queue)
(C++11)
specializes the
algorithm
(function template)
Synopsis
#include<compare>#include<initializer_list>namespacestd{// class template queuetemplate<classT,classContainer=deque<T>>classqueue;template<classT,classContainer>constexprbooloperator==(constqueue<T,Container>&x,constqueue<T,Container>&y);template<classT,classContainer>constexprbooloperator!=(constqueue<T,Container>&x,constqueue<T,Container>&y);template<classT,classContainer>constexprbooloperator<(constqueue<T,Container>&x,constqueue<T,Container>&y);template<classT,classContainer>constexprbooloperator>(constqueue<T,Container>&x,constqueue<T,Container>&y);template<classT,classContainer>constexprbooloperator<=(constqueue<T,Container>&x,constqueue<T,Container>&y);template<classT,classContainer>constexprbooloperator>=(constqueue<T,Container>&x,constqueue<T,Container>&y);template<classT,three_way_comparableContainer>constexprcompare_three_way_result_t<Container>operator<=>(constqueue<T,Container>&x,constqueue<T,Container>&y);template<classT,classContainer>constexprvoidswap(queue<T,Container>&x,queue<T,Container>&y)noexcept(noexcept(x.swap(y)));template<classT,classContainer,classAlloc>structuses_allocator<queue<T,Container>,Alloc>;// formatter specialization for queuetemplate<classCharT,classT,formattable<CharT>Container>structformatter<queue<T,Container>,CharT>;template<classT,classContainer>constexprboolenable_nonlocking_formatter_optimization<queue<T,Container>>=false;// class template priority_queuetemplate<classT,classContainer=vector<T>,classCompare=less<typenameContainer::value_type>>classpriority_queue;template<classT,classContainer,classCompare>constexprvoidswap(priority_queue<T,Container,Compare>&x,priority_queue<T,Container,Compare>&y)noexcept(noexcept(x.swap(y)));template<classT,classContainer,classCompare,classAlloc>structuses_allocator<priority_queue<T,Container,Compare>,Alloc>;// formatter specialization for priority_queuetemplate<classCharT,classT,formattable<CharT>Container,classCompare>structformatter<priority_queue<T,Container,Compare>,CharT>;template<classT,classContainer,classCompare>constexprboolenable_nonlocking_formatter_optimization<priority_queue<T,Container,Compare>>=false;}Class template
namespacestd{template<classT,classContainer=deque<T>>classqueue{public:usingvalue_type=Container::value_type;usingreference=Container::reference;usingconst_reference=Container::const_reference;usingsize_type=Container::size_type;usingcontainer_type=Container;protected:Containerc;public:constexprqueue():queue(Container()){}constexprexplicitqueue(constContainer&);constexprexplicitqueue(Container&&);template<classInputIter>constexprqueue(InputIterfirst,InputIterlast);template<container-compatible-range<T>R>constexprqueue(from_range_t,R&&rg);template<classAlloc>constexprexplicitqueue(constAlloc&);template<classAlloc>constexprqueue(constContainer&,constAlloc&);template<classAlloc>constexprqueue(Container&&,constAlloc&);template<classAlloc>constexprqueue(constqueue&,constAlloc&);template<classAlloc>constexprqueue(queue&&,constAlloc&);template<classInputIter,classAlloc>constexprqueue(InputIterfirst,InputIterlast,constAlloc&);template<container-compatible-range<T>R,classAlloc>constexprqueue(from_range_t,R&&rg,constAlloc&);constexprboolempty()const{returnc.empty();}constexprsize_typesize()const{returnc.size();}constexprreferencefront(){returnc.front();}constexprconst_referencefront()const{returnc.front();}constexprreferenceback(){returnc.back();}constexprconst_referenceback()const{returnc.back();}constexprvoidpush(constvalue_type&x){c.push_back(x);}constexprvoidpush(value_type&&x){c.push_back(std::move(x));}template<container-compatible-range<T>R>constexprvoidpush_range(R&&rg);template<class...Args>constexprdecltype(auto)emplace(Args&&...args){returnc.emplace_back(std::forward<Args>(args)...);}constexprvoidpop(){c.pop_front();}constexprvoidswap(queue&q)noexcept(is_nothrow_swappable_v<Container>){usingstd::swap;swap(c,q.c);}};template<classContainer>queue(Container)->queue<typenameContainer::value_type,Container>;template<classInputIter>queue(InputIter,InputIter)->queue</*iter-value-type*/<InputIter>>;template<ranges::input_rangeR>queue(from_range_t,R&&)->queue<ranges::range_value_t<R>>;template<classContainer,classAllocator>queue(Container,Allocator)->queue<typenameContainer::value_type,Container>;template<classInputIter,classAllocator>queue(InputIter,InputIter,Allocator)->queue</*iter-value-type*/<InputIter>,deque</*iter-value-type*/<InputIter>,Allocator>>;template<ranges::input_rangeR,classAllocator>queue(from_range_t,R&&,Allocator)->queue<ranges::range_value_t<R>,deque<ranges::range_value_t<R>,Allocator>>;template<classT,classContainer,classAlloc>structuses_allocator<queue<T,Container>,Alloc>:uses_allocator<Container,Alloc>::type{};}Class template
namespacestd{template<classT,classContainer=vector<T>,classCompare=less<typenameContainer::value_type>>classpriority_queue{public:usingvalue_type=Container::value_type;usingreference=Container::reference;usingconst_reference=Container::const_reference;usingsize_type=Container::size_type;usingcontainer_type=Container;usingvalue_compare=Compare;protected:Containerc;Comparecomp;public:constexprpriority_queue():priority_queue(Compare()){}constexprexplicitpriority_queue(constCompare&x):priority_queue(x,Container()){}constexprpriority_queue(constCompare&x,constContainer&);constexprpriority_queue(constCompare&x,Container&&);template<classInputIter>constexprpriority_queue(InputIterfirst,InputIterlast,constCompare&x=Compare());template<classInputIter>constexprpriority_queue(InputIterfirst,InputIterlast,constCompare&x,constContainer&);template<classInputIter>constexprpriority_queue(InputIterfirst,InputIterlast,constCompare&x,Container&&);template<container-compatible-range<T>R>constexprpriority_queue(from_range_t,R&&rg,constCompare&x=Compare());template<classAlloc>constexprexplicitpriority_queue(constAlloc&);template<classAlloc>constexprpriority_queue(constCompare&,constAlloc&);template<classAlloc>constexprpriority_queue(constCompare&,constContainer&,constAlloc&);template<classAlloc>constexprpriority_queue(constCompare&,Container&&,constAlloc&);template<classAlloc>constexprpriority_queue(constpriority_queue&,constAlloc&);template<classAlloc>constexprpriority_queue(priority_queue&&,constAlloc&);template<classInputIter,classAlloc>constexprpriority_queue(InputIter,InputIter,constAlloc&);template<classInputIter,classAlloc>constexprpriority_queue(InputIter,InputIter,constCompare&,constAlloc&);template<classInputIter,classAlloc>constexprpriority_queue(InputIter,InputIter,constCompare&,constContainer&,constAlloc&);template<classInputIter,classAlloc>constexprpriority_queue(InputIter,InputIter,constCompare&,Container&&,constAlloc&);template<container-compatible-range<T>R,classAlloc>constexprpriority_queue(from_range_t,R&&rg,constCompare&,constAlloc&);template<container-compatible-range<T>R,classAlloc>constexprpriority_queue(from_range_t,R&&rg,constAlloc&);constexprboolempty()const{returnc.empty();}constexprsize_typesize()const{returnc.size();}constexprconst_referencetop()const{returnc.front();}constexprvoidpush(constvalue_type&x);constexprvoidpush(value_type&&x);template<container-compatible-range<T>R>constexprvoidpush_range(R&&rg);template<class...Args>constexprvoidemplace(Args&&...args);constexprvoidpop();constexprvoidswap(priority_queue&q)noexcept(is_nothrow_swappable_v<Container>&&is_nothrow_swappable_v<Compare>){usingstd::swap;swap(c,q.c);swap(comp,q.comp);}};template<classCompare,classContainer>priority_queue(Compare,Container)->priority_queue<typenameContainer::value_type,Container,Compare>;template<classInputIter,classCompare=less</*iter-value-type*/<InputIter>>,classContainer=vector</*iter-value-type*/<InputIter>>>priority_queue(InputIter,InputIter,Compare=Compare(),Container=Container())->priority_queue</*iter-value-type*/<InputIter>,Container,Compare>;template<ranges::input_rangeR,classCompare=less<ranges::range_value_t<R>>>priority_queue(from_range_t,R&&,Compare=Compare())->priority_queue<ranges::range_value_t<R>,vector<ranges::range_value_t<R>>,Compare>;template<classCompare,classContainer,classAllocator>priority_queue(Compare,Container,Allocator)->priority_queue<typenameContainer::value_type,Container,Compare>;template<classInputIter,classAllocator>priority_queue(InputIter,InputIter,Allocator)->priority_queue</*iter-value-type*/<InputIter>,vector</*iter-value-type*/<InputIter>,Allocator>,less</*iter-value-type*/<InputIter>>>;template<classInputIter,classCompare,classAllocator>priority_queue(InputIter,InputIter,Compare,Allocator)->priority_queue</*iter-value-type*/<InputIter>,vector</*iter-value-type*/<InputIter>,Allocator>,Compare>;template<classInputIter,classCompare,classContainer,classAllocator>priority_queue(InputIter,InputIter,Compare,Container,Allocator)->priority_queue<typenameContainer::value_type,Container,Compare>;template<ranges::input_rangeR,classCompare,classAllocator>priority_queue(from_range_t,R&&,Compare,Allocator)->priority_queue<ranges::range_value_t<R>,vector<ranges::range_value_t<R>,Allocator>,Compare>;template<ranges::input_rangeR,classAllocator>priority_queue(from_range_t,R&&,Allocator)->priority_queue<ranges::range_value_t<R>,vector<ranges::range_value_t<R>,Allocator>>;// no equality is providedtemplate<classT,classContainer,classCompare,classAlloc>structuses_allocator<priority_queue<T,Container,Compare>,Alloc>:uses_allocator<Container,Alloc>::type{};}