Standard library header <deque>
From cppreference.com
This header is part of the containers library.
Includes | |
(C++20) |
Three-way comparison operator support |
(C++11) |
std::initializer_list class template |
Classes | |
| double-ended queue (class template) | |
Functions | |
(removed in C++20)(removed in C++20)(removed in C++20)(removed in C++20)(removed in C++20)(C++20) |
lexicographically compares the values of two deques (function template) |
| specializes the std::swap algorithm (function template) | |
| erases all elements satisfying specific criteria (function template) | |
Range access | |
(C++11)(C++14) |
returns an iterator to the beginning of a container or array (function template) |
(C++11)(C++14) |
returns an iterator to the end of a container or array (function template) |
(C++14) |
returns a reverse iterator to the beginning of a container or array (function template) |
(C++14) |
returns a reverse end iterator for a container or array (function template) |
(C++17)(C++20) |
returns the size of a container or array (function template) |
(C++17) |
checks whether the container is empty (function template) |
(C++17) |
obtains the pointer to the underlying array (function template) |
Synopsis
#include <compare>
#include <initializer_list>
namespace std {
// class template deque
template<class T, class Allocator = allocator<T>> class deque;
template<class T, class Allocator>
constexpr bool operator==(const deque<T, Allocator>& x, const deque<T, Allocator>& y);
template<class T, class Allocator>
constexpr /*synth-three-way-result*/<T> operator<=>(const deque<T, Allocator>& x,
const deque<T, Allocator>& y);
template<class T, class Allocator>
constexpr void swap(deque<T, Allocator>& x,
deque<T, Allocator>& y) noexcept(noexcept(x.swap(y)));
// erasure
template<class T, class Allocator, class U = T>
constexpr typename deque<T, Allocator>::size_type erase(deque<T, Allocator>& c,
const U& value);
template<class T, class Allocator, class Predicate>
constexpr typename deque<T, Allocator>::size_type erase_if(deque<T, Allocator>& c,
Predicate pred);
namespace pmr {
template<class T> using deque = std::deque<T, polymorphic_allocator<T>>;
}
}
Class template std::deque
namespace std {
template<class T, class Allocator = allocator<T>> class deque
{
public:
// types
using value_type = T;
using allocator_type = Allocator;
using pointer = allocator_traits<Allocator>::pointer;
using const_pointer = allocator_traits<Allocator>::const_pointer;
using reference = value_type&;
using const_reference = const value_type&;
using size_type = /* implementation-defined */;
using difference_type = /* implementation-defined */;
using iterator = /* implementation-defined */;
using const_iterator = /* implementation-defined */;
using reverse_iterator = std::reverse_iterator<iterator>;
using const_reverse_iterator = std::reverse_iterator<const_iterator>;
// construct/copy/destroy
constexpr deque()
: deque(Allocator())
{
}
constexpr explicit deque(const Allocator&);
constexpr explicit deque(size_type n, const Allocator& = Allocator());
constexpr deque(size_type n, const T& value, const Allocator& = Allocator());
template<class InputIter>
constexpr deque(InputIter first, InputIter last, const Allocator& = Allocator());
template<container-compatible-range<T> R>
constexpr deque(from_range_t, R&& rg, const Allocator& = Allocator());
constexpr deque(const deque& x);
constexpr deque(deque&&);
constexpr deque(const deque&, const type_identity_t<Allocator>&);
constexpr deque(deque&&, const type_identity_t<Allocator>&);
constexpr deque(initializer_list<T>, const Allocator& = Allocator());
constexpr ~deque();
constexpr deque& operator=(const deque& x);
constexpr deque& operator=(deque&& x) noexcept(
allocator_traits<Allocator>::is_always_equal::value);
constexpr deque& operator=(initializer_list<T>);
template<class InputIter> constexpr void assign(InputIter first, InputIter last);
template<container-compatible-range<T> R> constexpr void assign_range(R&& rg);
constexpr void assign(size_type n, const T& t);
constexpr void assign(initializer_list<T>);
constexpr allocator_type get_allocator() const noexcept;
// iterators
constexpr iterator begin() noexcept;
constexpr const_iterator begin() const noexcept;
constexpr iterator end() noexcept;
constexpr const_iterator end() const noexcept;
constexpr reverse_iterator rbegin() noexcept;
constexpr const_reverse_iterator rbegin() const noexcept;
constexpr reverse_iterator rend() noexcept;
constexpr const_reverse_iterator rend() const noexcept;
constexpr const_iterator cbegin() const noexcept;
constexpr const_iterator cend() const noexcept;
constexpr const_reverse_iterator crbegin() const noexcept;
constexpr const_reverse_iterator crend() const noexcept;
// capacity
constexpr bool empty() const noexcept;
constexpr size_type size() const noexcept;
constexpr size_type max_size() const noexcept;
constexpr void resize(size_type sz);
constexpr void resize(size_type sz, const T& c);
constexpr void shrink_to_fit();
// element access
constexpr reference operator[](size_type n);
constexpr const_reference operator[](size_type n) const;
constexpr reference at(size_type n);
constexpr const_reference at(size_type n) const;
constexpr reference front();
constexpr const_reference front() const;
constexpr reference back();
constexpr const_reference back() const;
// modifiers
template<class... Args> constexpr reference emplace_front(Args&&... args);
template<class... Args> constexpr reference emplace_back(Args&&... args);
template<class... Args>
constexpr iterator emplace(const_iterator position, Args&&... args);
constexpr void push_front(const T& x);
constexpr void push_front(T&& x);
template<container-compatible-range<T> R> constexpr void prepend_range(R&& rg);
constexpr void push_back(const T& x);
constexpr void push_back(T&& x);
template<container-compatible-range<T> R> constexpr void append_range(R&& rg);
constexpr iterator insert(const_iterator position, const T& x);
constexpr iterator insert(const_iterator position, T&& x);
constexpr iterator insert(const_iterator position, size_type n, const T& x);
template<class InputIter>
constexpr iterator insert(const_iterator position, InputIter first, InputIter last);
template<container-compatible-range<T> R>
constexpr iterator insert_range(const_iterator position, R&& rg);
constexpr iterator insert(const_iterator position, initializer_list<T>);
constexpr void pop_front();
constexpr void pop_back();
constexpr iterator erase(const_iterator position);
constexpr iterator erase(const_iterator first, const_iterator last);
constexpr void swap(deque&) noexcept(
allocator_traits<Allocator>::is_always_equal::value);
constexpr void clear() noexcept;
};
template<class InputIter, class Allocator = allocator</*iter-value-type*/<InputIter>>>
deque(InputIter, InputIter, Allocator = Allocator())
-> deque</*iter-value-type*/<InputIter>, Allocator>;
template<ranges::input_range R, class Allocator = allocator<ranges::range_value_t<R>>>
deque(from_range_t, R&&, Allocator = Allocator())
-> deque<ranges::range_value_t<R>, Allocator>;
}