Каждый адаптер контейнера принимаетContainer параметр шаблона, а каждый конструктор -Container аргумент ссылки. Этот контейнер копируется вContainer член каждого адаптера. Если контейнер принимает распределитель, то совместимый распределитель может быть передан в конструктор адаптера. В противном случае для аргумента контейнера используется обычная конструкция копирования или перемещения. Первый параметр шаблонаT адаптеров контейнера должен обозначать тот же тип, что иContainer::value_type.
Для контейнерных адаптеров ни однаswap функция не генерирует исключение, если это исключение не вызвано заменой адаптераContainer или Compare объекта (если есть).
Руководство по вычету для контейнерного адаптера не должно участвовать в разрешении перегрузки, если выполняется одно из следующих условий:
У него естьInputIterator параметр шаблона, и для этого параметра выводится тип, который не квалифицируется как итератор ввода.
У него естьCompare параметр шаблона, и для этого параметра выводится тип, который квалифицируется как распределитель.
У него естьContainer параметр шаблона, и для этого параметра выводится тип, который квалифицируется как распределитель.
У него естьAllocator параметр шаблона, и для этого параметра выводится тип, который не квалифицируется как распределитель.
У него есть параметрыContainer иAllocator шаблона, иuses_allocator_v<Container, Allocator> естьfalse.
#include <initializer_list> namespace std { template <class T, class Container = deque<T>> class queue; template <class T, class Container = vector<T>, class Compare = less<typename Container::value_type>> class priority_queue; template <class T, class Container> bool operator==(const queue<T, Container>& x, const queue<T, Container>& y); template <class T, class Container> bool operator< (const queue<T, Container>& x, const queue<T, Container>& y); template <class T, class Container> bool operator!=(const queue<T, Container>& x, const queue<T, Container>& y); template <class T, class Container> bool operator> (const queue<T, Container>& x, const queue<T, Container>& y); template <class T, class Container> bool operator>=(const queue<T, Container>& x, const queue<T, Container>& y); template <class T, class Container> bool operator<=(const queue<T, Container>& x, const queue<T, Container>& y); template <class T, class Container> void swap(queue<T, Container>& x, queue<T, Container>& y) noexcept(noexcept(x.swap(y))); template <class T, class Container, class Compare> void swap(priority_queue<T, Container, Compare>& x, priority_queue<T, Container, Compare>& y) noexcept(noexcept(x.swap(y))); }
#include <initializer_list> namespace std { template <class T, class Container = deque<T>> class stack; template <class T, class Container> bool operator==(const stack<T, Container>& x, const stack<T, Container>& y); template <class T, class Container> bool operator< (const stack<T, Container>& x, const stack<T, Container>& y); template <class T, class Container> bool operator!=(const stack<T, Container>& x, const stack<T, Container>& y); template <class T, class Container> bool operator> (const stack<T, Container>& x, const stack<T, Container>& y); template <class T, class Container> bool operator>=(const stack<T, Container>& x, const stack<T, Container>& y); template <class T, class Container> bool operator<=(const stack<T, Container>& x, const stack<T, Container>& y); template <class T, class Container> void swap(stack<T, Container>& x, stack<T, Container>& y) noexcept(noexcept(x.swap(y))); }
Любая последовательность контейнер поддержки операций front(), back(), push_back() и pop_front() может быть использован для создания экземпляров queue. В частности, list и deque можно использовать.
namespace std { template <class T, class Container = deque<T>> class queue { public: using value_type = typename Container::value_type; using reference = typename Container::reference; using const_reference = typename Container::const_reference; using size_type = typename Container::size_type; using container_type = Container; protected: Container c; public: explicit queue(const Container&); explicit queue(Container&& = Container()); template <class Alloc> explicit queue(const Alloc&); template <class Alloc> queue(const Container&, const Alloc&); template <class Alloc> queue(Container&&, const Alloc&); template <class Alloc> queue(const queue&, const Alloc&); template <class Alloc> queue(queue&&, const Alloc&); bool empty() const { return c.empty(); } size_type size() const { return c.size(); } reference front() { return c.front(); } const_reference front() const { return c.front(); } reference back() { return c.back(); } const_reference back() const { return c.back(); } void push(const value_type& x) { c.push_back(x); } void push(value_type&& x) { c.push_back(std::move(x)); } template <class... Args> reference emplace(Args&&... args) { return c.emplace_back(std::forward<Args>(args)...); } void pop() { c.pop_front(); } void swap(queue& q) noexcept(is_nothrow_swappable_v<Container>) { using std::swap; swap(c, q.c); } }; template<class Container> queue(Container) -> queue<typename Container::value_type, Container>; template<class Container, class Allocator> queue(Container, Allocator) -> queue<typename Container::value_type, Container>; template <class T, class Container> bool operator==(const queue<T, Container>& x, const queue<T, Container>& y); template <class T, class Container> bool operator< (const queue<T, Container>& x, const queue<T, Container>& y); template <class T, class Container> bool operator!=(const queue<T, Container>& x, const queue<T, Container>& y); template <class T, class Container> bool operator> (const queue<T, Container>& x, const queue<T, Container>& y); template <class T, class Container> bool operator>=(const queue<T, Container>& x, const queue<T, Container>& y); template <class T, class Container> bool operator<=(const queue<T, Container>& x, const queue<T, Container>& y); template <class T, class Container> void swap(queue<T, Container>& x, queue<T, Container>& y) noexcept(noexcept(x.swap(y))); template <class T, class Container, class Alloc> struct uses_allocator<queue<T, Container>, Alloc> : uses_allocator<Container, Alloc>::type { }; }
explicit queue(const Container& cont);
explicit queue(Container&& cont = Container());
Еслиuses_allocator_v<container_type, Alloc> -false конструкторы в этом подпункте, не должны участвовать в разрешении перегрузки.
template <class Alloc> explicit queue(const Alloc& a);
template <class Alloc> queue(const container_type& cont, const Alloc& a);
template <class Alloc> queue(container_type&& cont, const Alloc& a);
template <class Alloc> queue(const queue& q, const Alloc& a);
template <class Alloc> queue(queue&& q, const Alloc& a);
template <class T, class Container>
bool operator==(const queue<T, Container>& x, const queue<T, Container>& y);
template <class T, class Container>
bool operator!=(const queue<T, Container>& x, const queue<T, Container>& y);
template <class T, class Container>
bool operator< (const queue<T, Container>& x, const queue<T, Container>& y);
template <class T, class Container>
bool operator<=(const queue<T, Container>& x, const queue<T, Container>& y);
template <class T, class Container>
bool operator> (const queue<T, Container>& x, const queue<T, Container>& y);
template <class T, class Container>
bool operator>=(const queue<T, Container>& x,
const queue<T, Container>& y);
template <class T, class Container>
void swap(queue<T, Container>& x, queue<T, Container>& y) noexcept(noexcept(x.swap(y)));
Remarks: Эта функция не будет участвовать в разрешении перегрузки , еслиis_swappable_v<Container> неtrue.
Любая последовательность контейнер с произвольным доступом итераторы и вспомогательные операции front(), push_back() и pop_back() может быть использован для создания экземпляров priority_queue. В частности, vector и deque можно использовать. Создание экземпляра priority_queue также включает в себя предоставление функции или функционального объекта для выполнения сравнения приоритетов; библиотека предполагает, что функция или функциональный объект определяет файлstrict weak ordering.
namespace std {
template <class T, class Container = vector<T>,
class Compare = less<typename Container::value_type>>
class priority_queue {
public:
using value_type = typename Container::value_type;
using reference = typename Container::reference;
using const_reference = typename Container::const_reference;
using size_type = typename Container::size_type;
using container_type = Container;
using value_compare = Compare;
protected:
Container c;
Compare comp;
public:
priority_queue(const Compare& x, const Container&);
explicit priority_queue(const Compare& x = Compare(), Container&& = Container());
template <class InputIterator>
priority_queue(InputIterator first, InputIterator last,
const Compare& x, const Container&);
template <class InputIterator>
priority_queue(InputIterator first, InputIterator last,
const Compare& x = Compare(), Container&& = Container());
template <class Alloc> explicit priority_queue(const Alloc&);
template <class Alloc> priority_queue(const Compare&, const Alloc&);
template <class Alloc> priority_queue(const Compare&, const Container&, const Alloc&);
template <class Alloc> priority_queue(const Compare&, Container&&, const Alloc&);
template <class Alloc> priority_queue(const priority_queue&, const Alloc&);
template <class Alloc> priority_queue(priority_queue&&, const Alloc&);
bool empty() const { return c.empty(); }
size_type size() const { return c.size(); }
const_reference top() const { return c.front(); }
void push(const value_type& x);
void push(value_type&& x);
template <class... Args> void emplace(Args&&... args);
void pop();
void swap(priority_queue& q) noexcept(is_nothrow_swappable_v<Container> &&
is_nothrow_swappable_v<Compare>)
{ using std::swap; swap(c, q.c); swap(comp, q.comp); }
};
template<class Compare, class Container>
priority_queue(Compare, Container)
-> priority_queue<typename Container::value_type, Container, Compare>;
template<class InputIterator,
class Compare = less<typename iterator_traits<InputIterator>::value_type>,
class Container = vector<typename iterator_traits<InputIterator>::value_type>>
priority_queue(InputIterator, InputIterator, Compare = Compare(), Container = Container())
-> priority_queue<typename iterator_traits<InputIterator>::value_type, Container, Compare>;
template<class Compare, class Container, class Allocator>
priority_queue(Compare, Container, Allocator)
-> priority_queue<typename Container::value_type, Container, Compare>;
// no equality is provided
template <class T, class Container, class Compare>
void swap(priority_queue<T, Container, Compare>& x,
priority_queue<T, Container, Compare>& y) noexcept(noexcept(x.swap(y)));
template <class T, class Container, class Compare, class Alloc>
struct uses_allocator<priority_queue<T, Container, Compare>, Alloc>
: uses_allocator<Container, Alloc>::type { };
}
priority_queue(const Compare& x, const Container& y);
explicit priority_queue(const Compare& x = Compare(), Container&& y = Container());
Requires: x должен определить astrict weak ordering.
Effects: Инициализируется comp с помощью x и c с y (копировать построение или перемещать построение, если необходимо); звонки make_heap(c.begin(), c.end(), comp).
template <class InputIterator>
priority_queue(InputIterator first, InputIterator last,
const Compare& x,
const Container& y);
template <class InputIterator>
priority_queue(InputIterator first, InputIterator last,
const Compare& x = Compare(),
Container&& y = Container());
Requires: x должен определить astrict weak ordering.
Еслиuses_allocator_v<container_type, Alloc> -false конструкторы в этом подпункте, не должны участвовать в разрешении перегрузки.
template <class Alloc> explicit priority_queue(const Alloc& a);
template <class Alloc> priority_queue(const Compare& compare, const Alloc& a);
template <class Alloc>
priority_queue(const Compare& compare, const Container& cont, const Alloc& a);
Effects: Инициализацияc сcont первым аргументом , а вa качестве второго аргумента, и инициализируетcomp сcompare; звонкиmake_heap(c.begin(), c.end(), comp).
template <class Alloc>
priority_queue(const Compare& compare, Container&& cont, const Alloc& a);
Effects: Инициализацияc сstd::move(cont) первым аргументом , а вa качестве второго аргумента, и инициализируетcomp сcompare; звонкиmake_heap(c.begin(), c.end(), comp).
template <class Alloc> priority_queue(const priority_queue& q, const Alloc& a);
Effects: Инициализацияc сq.c первым аргументом , а вa качестве второго аргумента, и инициализируетcomp сq.comp.
template <class Alloc> priority_queue(priority_queue&& q, const Alloc& a);
void push(const value_type& x);
void push(value_type&& x);
template <class... Args> void emplace(Args&&... args)
Effects: Как будто по:
c.emplace_back(std::forward<Args>(args)...); push_heap(c.begin(), c.end(), comp);
void pop();
template <class T, class Container, class Compare>
void swap(priority_queue<T, Container, Compare>& x,
priority_queue<T, Container, Compare>& y) noexcept(noexcept(x.swap(y)));
Remarks: Эта функция не будет участвовать в разрешении перегрузки , еслиis_swappable_v<Container> неtrue и is_swappable_v<Compare> являетсяtrue.
Любой контейнер последовательности поддержки операций back(), push_back() и pop_back() может быть использован для создания экземпляра stack. В частности, vector, list и deque может быть использовано.
namespace std { template <class T, class Container = deque<T>> class stack { public: using value_type = typename Container::value_type; using reference = typename Container::reference; using const_reference = typename Container::const_reference; using size_type = typename Container::size_type; using container_type = Container; protected: Container c; public: explicit stack(const Container&); explicit stack(Container&& = Container()); template <class Alloc> explicit stack(const Alloc&); template <class Alloc> stack(const Container&, const Alloc&); template <class Alloc> stack(Container&&, const Alloc&); template <class Alloc> stack(const stack&, const Alloc&); template <class Alloc> stack(stack&&, const Alloc&); bool empty() const { return c.empty(); } size_type size() const { return c.size(); } reference top() { return c.back(); } const_reference top() const { return c.back(); } void push(const value_type& x) { c.push_back(x); } void push(value_type&& x) { c.push_back(std::move(x)); } template <class... Args> reference emplace(Args&&... args) { return c.emplace_back(std::forward<Args>(args)...); } void pop() { c.pop_back(); } void swap(stack& s) noexcept(is_nothrow_swappable_v<Container>) { using std::swap; swap(c, s.c); } }; template<class Container> stack(Container) -> stack<typename Container::value_type, Container>; template<class Container, class Allocator> stack(Container, Allocator) -> stack<typename Container::value_type, Container>; template <class T, class Container> bool operator==(const stack<T, Container>& x, const stack<T, Container>& y); template <class T, class Container> bool operator< (const stack<T, Container>& x, const stack<T, Container>& y); template <class T, class Container> bool operator!=(const stack<T, Container>& x, const stack<T, Container>& y); template <class T, class Container> bool operator> (const stack<T, Container>& x, const stack<T, Container>& y); template <class T, class Container> bool operator>=(const stack<T, Container>& x, const stack<T, Container>& y); template <class T, class Container> bool operator<=(const stack<T, Container>& x, const stack<T, Container>& y); template <class T, class Container> void swap(stack<T, Container>& x, stack<T, Container>& y) noexcept(noexcept(x.swap(y))); template <class T, class Container, class Alloc> struct uses_allocator<stack<T, Container>, Alloc> : uses_allocator<Container, Alloc>::type { }; }
explicit stack(const Container& cont);
explicit stack(Container&& cont = Container());
Еслиuses_allocator_v<container_type, Alloc> -false конструкторы в этом подпункте, не должны участвовать в разрешении перегрузки.
template <class Alloc> explicit stack(const Alloc& a);
template <class Alloc> stack(const container_type& cont, const Alloc& a);
template <class Alloc> stack(container_type&& cont, const Alloc& a);
template <class Alloc> stack(const stack& s, const Alloc& a);
template <class Alloc> stack(stack&& s, const Alloc& a);
template <class T, class Container>
bool operator==(const stack<T, Container>& x, const stack<T, Container>& y);
template <class T, class Container>
bool operator!=(const stack<T, Container>& x, const stack<T, Container>& y);
template <class T, class Container>
bool operator< (const stack<T, Container>& x, const stack<T, Container>& y);
template <class T, class Container>
bool operator<=(const stack<T, Container>& x, const stack<T, Container>& y);
template <class T, class Container>
bool operator> (const stack<T, Container>& x, const stack<T, Container>& y);
template <class T, class Container>
bool operator>=(const stack<T, Container>& x, const stack<T, Container>& y);
template <class T, class Container>
void swap(stack<T, Container>& x, stack<T, Container>& y) noexcept(noexcept(x.swap(y)));
Remarks: Эта функция не будет участвовать в разрешении перегрузки , еслиis_swappable_v<Container> неtrue.