Semiconductor & Computer Engineering
From WikiChip
Difference between revisions of "c++/std/deque"
m (Jon moved page Deque Header - C++ to c++/std/deque) |
|||
| Line 1: | Line 1: | ||
| − | {{ | + | {{c++ title|<deque> Header}}{{C++ Standard Library}} |
| − | {{C++ Standard Library}} | ||
The header '''<deque>''' defines the deque container class, a double-ended queue. The <deque> header is part of the [[C++]] [[C++ Standard Library|Standard Library's]] [[Sequence containers - C++|sequence containers]]. | The header '''<deque>''' defines the deque container class, a double-ended queue. The <deque> header is part of the [[C++]] [[C++ Standard Library|Standard Library's]] [[Sequence containers - C++|sequence containers]]. | ||
Latest revision as of 20:15, 26 November 2015
The header <deque> defines the deque container class, a double-ended queue. The <deque> header is part of the C++ Standard Library's sequence containers.
Contents
Functions[edit]
| Function | Description | Since |
|---|---|---|
| operator == | Lexicographically compares deque values | C++98 |
| operator < | C++98 | |
| operator != | C++98 | |
| operator > | C++98 | |
| operator >= | C++98 | |
| operator <= | C++98 | |
| operator swap | Specialized swaps deque algorithm | C++98 |
Classes[edit]
| Class | Description | Since |
|---|---|---|
| deque | double-ended queue container | C++98 |
Synopsis[edit]
#include <initializer_list>
namespace std {
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>
bool operator<(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
template <class T, class Allocator>
bool operator!=(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
template <class T, class Allocator>
bool operator>(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
template <class T, class Allocator>
bool operator>=(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
template <class T, class Allocator>
bool 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);
}
std::deque[edit]
- Main article: deque/deque
namespace std {
template <class T, class Allocator = allocator<T> >
class deque {
public:
// types:
typedef value_type& reference;
typedef const value_type& const_reference;
typedef /* implementation-defined */ iterator;
typedef /* implementation-defined */ const_iterator;
typedef /* implementation-defined */ size_type;
typedef /* implementation-defined */ difference_type;
typedef T value_type;
typedef Allocator allocator_type;
typedef typename allocator_traits<Allocator>::pointer pointer;
typedef typename allocator_traits<Allocator>::const_pointer
const_pointer; typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
// construct/copy/destroy:
explicit deque(const Allocator& = Allocator());
explicit deque(size_type n);
deque(size_type n, const T& value,const Allocator& = Allocator());
template <class InputIterator>
deque(InputIterator first, InputIterator last,const Allocator& = Allocator());
deque(const deque& x);
deque(deque&&);
deque(const deque&, const Allocator&);
deque(deque&&, const Allocator&);
deque(initializer_list<T>, const Allocator& = Allocator());
~deque();
deque& operator=(const deque& x);
deque& operator=(deque&& x);
deque& operator=(initializer_list<T>);
template <class InputIterator>
void assign(InputIterator first, InputIterator last);
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:
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();
bool empty() const noexcept;
// 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> void emplace_front(Args&&... args);
template <class... Args> void 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);
void push_back(const T& x);
void push_back(T&& x);
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 InputIterator>
iterator insert (const_iterator position, InputIterator first, InputIterator last);
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&);
void clear() noexcept;
};
}