• Log in

#include <compare>
#include <initializer_list>
 
namespace std {
 // class template deque
 template<class T, class Allocator = allocator<T>>
 class deque;
 
 template<class T, class Allocator>
 bool operator==(const deque<T, Allocator>& x, const deque<T, Allocator>& y);
 template<class T, class Allocator>
 /*synth-three-way-result*/<T> operator<=>(const deque<T, Allocator>& x,
 const deque<T, Allocator>& y);
 
 template<class T, class Allocator>
 void swap(deque<T, Allocator>& x, deque<T, Allocator>& y) noexcept(noexcept(x.swap(y)));
 
 // erasure
 template<class T, class Allocator, class U = T>
 typename deque<T, Allocator>::size_type erase(deque<T, Allocator>& c, const U& value);
 template<class T, class Allocator, class Predicate>
 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>>;
 }
}

namespace std {
 template<class T, class Allocator = allocator<T>>
 class deque
 {
 public:
 // types
 using value_type = T;
 using allocator_type = Allocator;
 using pointer = typename allocator_traits<Allocator>::pointer;
 using const_pointer = typename 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
 deque()
 : deque(Allocator())
 {
 }
 explicit deque(const Allocator&);
 explicit deque(size_type n, const Allocator& = Allocator());
 deque(size_type n, const T& value, const Allocator& = Allocator());
 template<class InputIter>
 deque(InputIter first, InputIter last, const Allocator& = Allocator());
 template<container-compatible-range <T> R>
 deque(from_range_t, R&& rg, const Allocator& = Allocator());
 deque(const deque& x);
 deque(deque&&);
 deque(const deque&, const type_identity_t<Allocator>&);
 deque(deque&&, const type_identity_t<Allocator>&);
 deque(initializer_list<T>, const Allocator& = Allocator());
 
 ~deque();
 deque& operator=(const deque& x);
 deque& operator=(deque&& x) noexcept(
 allocator_traits<Allocator>::is_always_equal::value);
 deque& operator=(initializer_list<T>);
 template<class InputIter>
 void assign(InputIter first, InputIter last);
 template<container-compatible-range <T> R>
 void assign_range(R&& rg);
 void assign(size_type n, const T& t);
 void assign(initializer_list<T>);
 allocator_type get_allocator() const noexcept;
 
 // iterators
 iterator begin() noexcept;
 const_iterator begin() const noexcept;
 iterator end() noexcept;
 const_iterator end() const noexcept;
 reverse_iterator rbegin() noexcept;
 const_reverse_iterator rbegin() const noexcept;
 reverse_iterator rend() noexcept;
 const_reverse_iterator rend() const noexcept;
 
 const_iterator cbegin() const noexcept;
 const_iterator cend() const noexcept;
 const_reverse_iterator crbegin() const noexcept;
 const_reverse_iterator crend() const noexcept;
 
 // capacity
 bool empty() const noexcept;
 size_type size() const noexcept;
 size_type max_size() const noexcept;
 void resize(size_type sz);
 void resize(size_type sz, const T& c);
 void shrink_to_fit();
 
 // element access
 reference operator[](size_type n);
 const_reference operator[](size_type n) const;
 reference at(size_type n);
 const_reference at(size_type n) const;
 reference front();
 const_reference front() const;
 reference back();
 const_reference back() const;
 
 // modifiers
 template<class... Args>
 reference emplace_front(Args&&... args);
 template<class... Args>
 reference emplace_back(Args&&... args);
 template<class... Args>
 iterator emplace(const_iterator position, Args&&... args);
 
 void push_front(const T& x);
 void push_front(T&& x);
 template<container-compatible-range <T> R>
 void prepend_range(R&& rg);
 void push_back(const T& x);
 void push_back(T&& x);
 template<container-compatible-range <T> R>
 void append_range(R&& rg);
 
 iterator insert(const_iterator position, const T& x);
 iterator insert(const_iterator position, T&& x);
 iterator insert(const_iterator position, size_type n, const T& x);
 template<class InputIter>
 iterator insert(const_iterator position, InputIter first, InputIter last);
 template<container-compatible-range <T> R>
 iterator insert_range(const_iterator position, R&& rg);
 iterator insert(const_iterator position, initializer_list<T>);
 
 void pop_front();
 void pop_back();
 
 iterator erase(const_iterator position);
 iterator erase(const_iterator first, const_iterator last);
 void swap(deque&) noexcept(allocator_traits<Allocator>::is_always_equal::value);
 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>;
}